diff --git a/docs/about_model/convert_model/index.html b/docs/about_model/convert_model/index.html
index 4903f517..8d689893 100644
--- a/docs/about_model/convert_model/index.html
+++ b/docs/about_model/convert_model/index.html
@@ -1419,7 +1419,7 @@ <h3 id="离线转换httpsgithubcomrapidaipaddleocrmodelconverter"><a href="https
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1428,8 +1428,8 @@ <h3 id="离线转换httpsgithubcomrapidaipaddleocrmodelconverter"><a href="https
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/about_model/custom_different_model/index.html b/docs/about_model/custom_different_model/index.html
index 39d2be1f..dc659541 100644
--- a/docs/about_model/custom_different_model/index.html
+++ b/docs/about_model/custom_different_model/index.html
@@ -1486,7 +1486,7 @@ <h4 id="3-使用该模型">3. 使用该模型 <a href="#3-%e4%bd%bf%e7%94%a8%e8%
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1495,8 +1495,8 @@ <h4 id="3-使用该模型">3. 使用该模型 <a href="#3-%e4%bd%bf%e7%94%a8%e8%
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/about_model/download_onnx/index.html b/docs/about_model/download_onnx/index.html
index 13a326e6..814a2f8e 100644
--- a/docs/about_model/download_onnx/index.html
+++ b/docs/about_model/download_onnx/index.html
@@ -1401,7 +1401,7 @@ <h3 id="hugging-face-modelshttpshuggingfacecoswhlrapidocrtreemain"><a href="http
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1410,8 +1410,8 @@ <h3 id="hugging-face-modelshttpshuggingfacecoswhlrapidocrtreemain"><a href="http
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/about_model/index.html b/docs/about_model/index.html
index 2cb16ada..fc042bcf 100644
--- a/docs/about_model/index.html
+++ b/docs/about_model/index.html
@@ -1356,7 +1356,7 @@ <h1 class="content-title mb-0">
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1365,8 +1365,8 @@ <h1 class="content-title mb-0">
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/about_model/model_summary/index.html b/docs/about_model/model_summary/index.html
index 344bcaa4..c1a03bb1 100644
--- a/docs/about_model/model_summary/index.html
+++ b/docs/about_model/model_summary/index.html
@@ -1806,7 +1806,7 @@ <h4 id="文本识别模型">文本识别模型 <a href="#%e6%96%87%e6%9c%ac%e8%a
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1815,8 +1815,8 @@ <h4 id="文本识别模型">文本识别模型 <a href="#%e6%96%87%e6%9c%ac%e8%a
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/about_model/support_language/index.html b/docs/about_model/support_language/index.html
index b03d2e87..506dc090 100644
--- a/docs/about_model/support_language/index.html
+++ b/docs/about_model/support_language/index.html
@@ -1409,7 +1409,7 @@ <h3 id="转换教程convert_modelmd"><a data-bs-delay="{&#34;hide&#34;:300,&#34;
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1418,8 +1418,8 @@ <h3 id="转换教程convert_modelmd"><a data-bs-delay="{&#34;hide&#34;:300,&#34;
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/blog/01_optim_tutorial/index.html b/docs/blog/01_optim_tutorial/index.html
index 144c82da..79f976fc 100644
--- a/docs/blog/01_optim_tutorial/index.html
+++ b/docs/blog/01_optim_tutorial/index.html
@@ -1564,7 +1564,7 @@ <h4 id="情况二轻量中英文模型对个别英文或数字识别错误">情
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1573,8 +1573,8 @@ <h4 id="情况二轻量中英文模型对个别英文或数字识别错误">情
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/blog/02_config_parameter/index.html b/docs/blog/02_config_parameter/index.html
index 947a9043..5452089b 100644
--- a/docs/blog/02_config_parameter/index.html
+++ b/docs/blog/02_config_parameter/index.html
@@ -1701,7 +1701,7 @@ <h4 id="rec部分"><code>Rec</code>部分 <a href="#rec%e9%83%a8%e5%88%86" class
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1710,8 +1710,8 @@ <h4 id="rec部分"><code>Rec</code>部分 <a href="#rec%e9%83%a8%e5%88%86" class
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/blog/03_which_inference/index.html b/docs/blog/03_which_inference/index.html
index 03916767..9f49faaf 100644
--- a/docs/blog/03_which_inference/index.html
+++ b/docs/blog/03_which_inference/index.html
@@ -1402,7 +1402,7 @@ <h1 class="content-title mb-0">
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1411,8 +1411,8 @@ <h1 class="content-title mb-0">
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/blog/04_inference_summary/index.html b/docs/blog/04_inference_summary/index.html
index 7da950f5..e9549f95 100644
--- a/docs/blog/04_inference_summary/index.html
+++ b/docs/blog/04_inference_summary/index.html
@@ -1470,7 +1470,7 @@ <h3 id="paddlexhttpsaibaiducomai-docaistudiozlisojzjs"><a href="https://ai.baidu
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1479,8 +1479,8 @@ <h3 id="paddlexhttpsaibaiducomai-docaistudiozlisojzjs"><a href="https://ai.baidu
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/blog/05_rec_dict_onnx/index.html b/docs/blog/05_rec_dict_onnx/index.html
index 6b11e3e4..8ac28858 100644
--- a/docs/blog/05_rec_dict_onnx/index.html
+++ b/docs/blog/05_rec_dict_onnx/index.html
@@ -1499,7 +1499,7 @@ <h3 id="获取字典内容">获取字典内容 <a href="#%e8%8e%b7%e5%8f%96%e5%a
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1508,8 +1508,8 @@ <h3 id="获取字典内容">获取字典内容 <a href="#%e8%8e%b7%e5%8f%96%e5%a
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/blog/index.html b/docs/blog/index.html
index 21d3869c..5ba2dfaa 100644
--- a/docs/blog/index.html
+++ b/docs/blog/index.html
@@ -1356,7 +1356,7 @@ <h1 class="content-title mb-0">
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1365,8 +1365,8 @@ <h1 class="content-title mb-0">
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/business_support/index.html b/docs/business_support/index.html
index 5827a9cc..12a861b2 100644
--- a/docs/business_support/index.html
+++ b/docs/business_support/index.html
@@ -1409,7 +1409,7 @@ <h4 id="服务三国产操作系统ocr-docker部署">服务三：国产操作系
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1418,8 +1418,8 @@ <h4 id="服务三国产操作系统ocr-docker部署">服务三：国产操作系
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/changelog/index.html b/docs/changelog/index.html
index 04ba3d2f..5328a941 100644
--- a/docs/changelog/index.html
+++ b/docs/changelog/index.html
@@ -1356,7 +1356,7 @@ <h1 class="content-title mb-0">
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1365,8 +1365,8 @@ <h1 class="content-title mb-0">
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/changelog/rapidocr/index.html b/docs/changelog/rapidocr/index.html
index 466bd3a5..b9744318 100644
--- a/docs/changelog/rapidocr/index.html
+++ b/docs/changelog/rapidocr/index.html
@@ -1739,7 +1739,7 @@ <h4 id="2021-03-24-udpate">2021-03-24 udpate: <a href="#2021-03-24-udpate" class
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1748,8 +1748,8 @@ <h4 id="2021-03-24-udpate">2021-03-24 udpate: <a href="#2021-03-24-udpate" class
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/changelog/rapidocr_api/index.html b/docs/changelog/rapidocr_api/index.html
index a9c234ad..a99618c0 100644
--- a/docs/changelog/rapidocr_api/index.html
+++ b/docs/changelog/rapidocr_api/index.html
@@ -1405,7 +1405,7 @@ <h4 id="2023-05-22-api-update">🍜2023-05-22 api update: <a href="#2023-05-22-a
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1414,8 +1414,8 @@ <h4 id="2023-05-22-api-update">🍜2023-05-22 api update: <a href="#2023-05-22-a
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/changelog/rapidocr_paddle/index.html b/docs/changelog/rapidocr_paddle/index.html
index bd0b7b91..9e3ecdf3 100644
--- a/docs/changelog/rapidocr_paddle/index.html
+++ b/docs/changelog/rapidocr_paddle/index.html
@@ -1456,7 +1456,7 @@ <h4 id="2023-10-23-v139-update">2023-10-23 v1.3.9 update: <a href="#2023-10-23-v
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1465,8 +1465,8 @@ <h4 id="2023-10-23-v139-update">2023-10-23 v1.3.9 update: <a href="#2023-10-23-v
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/changelog/rapidocr_vino/index.html b/docs/changelog/rapidocr_vino/index.html
index 21e3883b..3ff04f8b 100644
--- a/docs/changelog/rapidocr_vino/index.html
+++ b/docs/changelog/rapidocr_vino/index.html
@@ -1401,7 +1401,7 @@ <h4 id="2024-05-18-v1319-update">2024-05-18 v1.3.19 update: <a href="#2024-05-18
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1410,8 +1410,8 @@ <h4 id="2024-05-18-v1319-update">2024-05-18 v1.3.19 update: <a href="#2024-05-18
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/changelog/rapidocr_web/index.html b/docs/changelog/rapidocr_web/index.html
index e31268d4..c4b716d0 100644
--- a/docs/changelog/rapidocr_web/index.html
+++ b/docs/changelog/rapidocr_web/index.html
@@ -1424,7 +1424,7 @@ <h4 id="2023-04-16-ocrweb-v011-update">🏸2023-04-16 ocrweb v0.1.1 update: <a h
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1433,8 +1433,8 @@ <h4 id="2023-04-16-ocrweb-v011-update">🏸2023-04-16 ocrweb v0.1.1 update: <a h
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/communicate/index.html b/docs/communicate/index.html
index c9cf9c45..ca0a0bb0 100644
--- a/docs/communicate/index.html
+++ b/docs/communicate/index.html
@@ -1414,7 +1414,7 @@ <h3 id="推荐-加入qq频道">(推荐) 加入QQ频道 <a href="#%e6%8e%a8%e8%8d
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1423,8 +1423,8 @@ <h3 id="推荐-加入qq频道">(推荐) 加入QQ频道 <a href="#%e6%8e%a8%e8%8d
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/faq/index.html b/docs/faq/index.html
index a1203e32..0964dff5 100644
--- a/docs/faq/index.html
+++ b/docs/faq/index.html
@@ -1462,7 +1462,7 @@ <h4 id="q-边缘总有一行文字无法识别怎么办">Q: 边缘总有一行
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1471,8 +1471,8 @@ <h4 id="q-边缘总有一行文字无法识别怎么办">Q: 边缘总有一行
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/index.html b/docs/index.html
index 7d2bf051..3656e464 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1501,7 +1501,7 @@ <h1 class="content-title mb-0">
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1510,8 +1510,8 @@ <h1 class="content-title mb-0">
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/inference_engine/index.html b/docs/inference_engine/index.html
index d8d96ab7..9f400dae 100644
--- a/docs/inference_engine/index.html
+++ b/docs/inference_engine/index.html
@@ -1305,7 +1305,7 @@ <h1 class="content-title mb-0">
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1314,8 +1314,8 @@ <h1 class="content-title mb-0">
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/inference_engine/onnxruntime/index.html b/docs/inference_engine/onnxruntime/index.html
index f596cfff..d57081a5 100644
--- a/docs/inference_engine/onnxruntime/index.html
+++ b/docs/inference_engine/onnxruntime/index.html
@@ -1313,7 +1313,7 @@ <h1 class="content-title mb-0">
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1322,8 +1322,8 @@ <h1 class="content-title mb-0">
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/inference_engine/onnxruntime/infer_optim/index.html b/docs/inference_engine/onnxruntime/infer_optim/index.html
index 733f93a3..08e095f3 100644
--- a/docs/inference_engine/onnxruntime/infer_optim/index.html
+++ b/docs/inference_engine/onnxruntime/infer_optim/index.html
@@ -1745,7 +1745,7 @@ <h4 id="参考资料">参考资料 <a href="#%e5%8f%82%e8%80%83%e8%b5%84%e6%96%9
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1754,8 +1754,8 @@ <h4 id="参考资料">参考资料 <a href="#%e5%8f%82%e8%80%83%e8%b5%84%e6%96%9
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/inference_engine/onnxruntime/onnxruntime-gpu/index.html b/docs/inference_engine/onnxruntime/onnxruntime-gpu/index.html
index dc10e605..1749f631 100644
--- a/docs/inference_engine/onnxruntime/onnxruntime-gpu/index.html
+++ b/docs/inference_engine/onnxruntime/onnxruntime-gpu/index.html
@@ -1460,7 +1460,7 @@ <h3 id="相关对比表格">相关对比表格 <a href="#%e7%9b%b8%e5%85%b3%e5%a
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1469,8 +1469,8 @@ <h3 id="相关对比表格">相关对比表格 <a href="#%e7%9b%b8%e5%85%b3%e5%a
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/inference_engine/openvino/index.html b/docs/inference_engine/openvino/index.html
index 1ae8187a..15e17ec4 100644
--- a/docs/inference_engine/openvino/index.html
+++ b/docs/inference_engine/openvino/index.html
@@ -1313,7 +1313,7 @@ <h1 class="content-title mb-0">
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1322,8 +1322,8 @@ <h1 class="content-title mb-0">
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/inference_engine/openvino/infer-gpu/index.html b/docs/inference_engine/openvino/infer-gpu/index.html
index 9ebc3c17..e7ac5a50 100644
--- a/docs/inference_engine/openvino/infer-gpu/index.html
+++ b/docs/inference_engine/openvino/infer-gpu/index.html
@@ -1380,7 +1380,7 @@ <h1 class="content-title mb-0">
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1389,8 +1389,8 @@ <h1 class="content-title mb-0">
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/inference_engine/openvino/infer/index.html b/docs/inference_engine/openvino/infer/index.html
index 23e502a8..e6203359 100644
--- a/docs/inference_engine/openvino/infer/index.html
+++ b/docs/inference_engine/openvino/infer/index.html
@@ -1632,7 +1632,7 @@ <h3 id="openvino与onnxruntime推理代码写法对比">OpenVINO与ONNXRuntime
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1641,8 +1641,8 @@ <h3 id="openvino与onnxruntime推理代码写法对比">OpenVINO与ONNXRuntime
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/install_usage/index.html b/docs/install_usage/index.html
index de745d88..b7fab953 100644
--- a/docs/install_usage/index.html
+++ b/docs/install_usage/index.html
@@ -1339,7 +1339,7 @@ <h1 class="content-title mb-0">
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1348,8 +1348,8 @@ <h1 class="content-title mb-0">
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/install_usage/rapidocr/cli/index.html b/docs/install_usage/rapidocr/cli/index.html
index 2ee54285..4af4bf97 100644
--- a/docs/install_usage/rapidocr/cli/index.html
+++ b/docs/install_usage/rapidocr/cli/index.html
@@ -823,26 +823,26 @@ <h3 id="使用示例">使用示例 <a href="#%e4%bd%bf%e7%94%a8%e7%a4%ba%e4%be%8
 		
 
 		<a class="nav-link  active"
-		   id="aefbdcTab" data-bs-toggle="tab" data-bs-target="#aefbdc"
-		   type="button" role="tab" aria-controls="aefbdc" aria-selected="true">图像预测</a>
+		   id="cdabefTab" data-bs-toggle="tab" data-bs-target="#cdabef"
+		   type="button" role="tab" aria-controls="cdabef" aria-selected="true">图像预测</a>
 
 		
 
 		<a class="nav-link "
-		   id="bdcfeaTab" data-bs-toggle="tab" data-bs-target="#bdcfea"
-		   type="button" role="tab" aria-controls="bdcfea" aria-selected="true">只使用检测</a>
+		   id="dfecbaTab" data-bs-toggle="tab" data-bs-target="#dfecba"
+		   type="button" role="tab" aria-controls="dfecba" aria-selected="true">只使用检测</a>
 
 		
 
 		<a class="nav-link "
-		   id="fcdabeTab" data-bs-toggle="tab" data-bs-target="#fcdabe"
-		   type="button" role="tab" aria-controls="fcdabe" aria-selected="true">只使用识别</a>
+		   id="aefbcdTab" data-bs-toggle="tab" data-bs-target="#aefbcd"
+		   type="button" role="tab" aria-controls="aefbcd" aria-selected="true">只使用识别</a>
 
 		
 
 		<a class="nav-link "
-		   id="bcedafTab" data-bs-toggle="tab" data-bs-target="#bcedaf"
-		   type="button" role="tab" aria-controls="bcedaf" aria-selected="true">可视化查看</a>
+		   id="efdcabTab" data-bs-toggle="tab" data-bs-target="#efdcab"
+		   type="button" role="tab" aria-controls="efdcab" aria-selected="true">可视化查看</a>
 
 		
 
@@ -858,7 +858,7 @@ <h3 id="使用示例">使用示例 <a href="#%e4%bd%bf%e7%94%a8%e7%a4%ba%e4%be%8
 
 
 
-<div class="tab-pane fade show active" id="aefbdc" role="tabpanel" aria-labelledby="nav-1">
+<div class="tab-pane fade show active" id="cdabef" role="tabpanel" aria-labelledby="nav-1">
 
 	
 
@@ -891,7 +891,7 @@ <h3 id="使用示例">使用示例 <a href="#%e4%bd%bf%e7%94%a8%e7%a4%ba%e4%be%8
 
 
 
-<div class="tab-pane fade" id="bdcfea" role="tabpanel" aria-labelledby="nav-1">
+<div class="tab-pane fade" id="dfecba" role="tabpanel" aria-labelledby="nav-1">
 
 	
 
@@ -924,7 +924,7 @@ <h3 id="使用示例">使用示例 <a href="#%e4%bd%bf%e7%94%a8%e7%a4%ba%e4%be%8
 
 
 
-<div class="tab-pane fade" id="fcdabe" role="tabpanel" aria-labelledby="nav-1">
+<div class="tab-pane fade" id="aefbcd" role="tabpanel" aria-labelledby="nav-1">
 
 	
 
@@ -957,7 +957,7 @@ <h3 id="使用示例">使用示例 <a href="#%e4%bd%bf%e7%94%a8%e7%a4%ba%e4%be%8
 
 
 
-<div class="tab-pane fade" id="bcedaf" role="tabpanel" aria-labelledby="nav-1">
+<div class="tab-pane fade" id="efdcab" role="tabpanel" aria-labelledby="nav-1">
 
 	
 
@@ -1681,7 +1681,7 @@ <h3 id="使用示例">使用示例 <a href="#%e4%bd%bf%e7%94%a8%e7%a4%ba%e4%be%8
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1690,8 +1690,8 @@ <h3 id="使用示例">使用示例 <a href="#%e4%bd%bf%e7%94%a8%e7%a4%ba%e4%be%8
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/install_usage/rapidocr/index.html b/docs/install_usage/rapidocr/index.html
index 694b66e2..88070397 100644
--- a/docs/install_usage/rapidocr/index.html
+++ b/docs/install_usage/rapidocr/index.html
@@ -1331,7 +1331,7 @@ <h1 class="content-title mb-0">
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1340,8 +1340,8 @@ <h1 class="content-title mb-0">
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/install_usage/rapidocr/index.xml b/docs/install_usage/rapidocr/index.xml
index c20f83b7..ace463d4 100644
--- a/docs/install_usage/rapidocr/index.xml
+++ b/docs/install_usage/rapidocr/index.xml
@@ -18,9 +18,9 @@
 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。
 版本情况 link各个库的最新版本：
 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系：
-版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。
-notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle
-pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源：
+版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。
+notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle
+pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源：
 pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下：
 info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper&amp;gt;=1.2.1 onnxruntime&amp;gt;=1.7.0 opencv_python&amp;gt;=4.5.1.48 numpy&amp;gt;=1.19.3 six&amp;gt;=1.15.0 Shapely&amp;gt;=1.7.1 PyYAML Pillow </description>
     </item>
@@ -31,10 +31,9 @@ info 如果在安装过程中，出现某个依赖包不能正确安装时，可
       <pubDate>Tue, 30 Aug 2022 15:39:03 +0100</pubDate>
       
       <guid>https://rapidai.github.io/RapidOCRDocs/docs/install_usage/rapidocr/usage/</guid>
-      <description>初始化 link类RapidOCR是主类，其初始化函数如下：
+      <description>初始化 linkRapidOCR类是主类，其初始化函数如下：
 class RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：
-以config.yaml方式
-找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=&amp;#34;your.yaml&amp;#34;) (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。
+以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=&amp;#34;your.yaml&amp;#34;) (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。
 info 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = &amp;#34;min&amp;#34;, det_thresh: float = 0.</description>
     </item>
     
diff --git a/docs/install_usage/rapidocr/install/index.html b/docs/install_usage/rapidocr/install/index.html
index bdd069aa..506ec3af 100644
--- a/docs/install_usage/rapidocr/install/index.html
+++ b/docs/install_usage/rapidocr/install/index.html
@@ -38,15 +38,15 @@
 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。
 版本情况 link各个库的最新版本：
 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系：
-版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。
-notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle
-pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源：
+版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。
+notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle
+pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源：
 pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下：
 info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper&gt;=1.2.1 onnxruntime&gt;=1.7.0 opencv_python&gt;=4.5.1.48 numpy&gt;=1.19.3 six&gt;=1.15.0 Shapely&gt;=1.7.1 PyYAML Pillow " />
 <meta property="og:type" content="article" />
 <meta property="og:url" content="https://rapidai.github.io/RapidOCRDocs/docs/install_usage/rapidocr/install/" /><meta property="og:image" content="https://rapidai.github.io/RapidOCRDocs/opengraph/card-base-2_hu06b1a92291a380a0d2e0ec03dab66b2f_17642_filter_4633963492798233046.png"/><meta property="article:section" content="docs" />
 
-<meta property="article:modified_time" content="2024-05-12T15:24:22+08:00" /><meta name="twitter:card" content="summary_large_image"/>
+<meta property="article:modified_time" content="2024-05-19T09:29:25+08:00" /><meta name="twitter:card" content="summary_large_image"/>
 <meta name="twitter:image" content="https://rapidai.github.io/RapidOCRDocs/opengraph/card-base-2_hu06b1a92291a380a0d2e0ec03dab66b2f_17642_filter_4633963492798233046.png"/>
 <meta name="twitter:title" content="安装"/>
 <meta name="twitter:description" content=" 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例
@@ -54,9 +54,9 @@
 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。
 版本情况 link各个库的最新版本：
 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系：
-版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。
-notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle
-pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源：
+版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。
+notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle
+pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源：
 pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下：
 info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper&gt;=1.2.1 onnxruntime&gt;=1.7.0 opencv_python&gt;=4.5.1.48 numpy&gt;=1.19.3 six&gt;=1.15.0 Shapely&gt;=1.7.1 PyYAML Pillow "/>
 
@@ -790,7 +790,7 @@ <h4 id="版本情况">版本情况 <a href="#%e7%89%88%e6%9c%ac%e6%83%85%e5%86%b
 </tr>
 </tbody>
 </table>
-<h4 id="安装">安装 <a href="#%e5%ae%89%e8%a3%85" class="anchor" aria-hidden="true"><i class="material-icons align-middle">link</i></a></h4><p>顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。</p>
+<h4 id="安装">安装 <a href="#%e5%ae%89%e8%a3%85" class="anchor" aria-hidden="true"><i class="material-icons align-middle">link</i></a></h4><p>顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。</p>
 
 <div class="alert alert-default d-flex" role="alert">
   <div class="flex-shrink-1 alert-icon">
@@ -799,7 +799,7 @@ <h4 id="安装">安装 <a href="#%e5%ae%89%e8%a3%85" class="anchor" aria-hidden=
   notifications
   </span></div>
   
-  <div class="w-100"><p>请使用Python3.6及以上版本。<br/> <code>rapidocr</code>系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考<a href="https://rapidai.github.io/RapidOCRDocs/docs/inference_engine/onnxruntime/onnxruntime-gpu/" rel="external" target="_blank">link<svg width="16" height="16" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><path fill="currentColor" d="M14 5c-.552 0-1-.448-1-1s.448-1 1-1h6c.552 0 1 .448 1 1v6c0 .552-.448 1-1 1s-1-.448-1-1v-3.586l-7.293 7.293c-.391.39-1.024.39-1.414 0-.391-.391-.391-1.024 0-1.414l7.293-7.293h-3.586zm-9 2c-.552 0-1 .448-1 1v11c0 .552.448 1 1 1h11c.552 0 1-.448 1-1v-4.563c0-.552.448-1 1-1s1 .448 1 1v4.563c0 1.657-1.343 3-3 3h-11c-1.657 0-3-1.343-3-3v-11c0-1.657 1.343-3 3-3h4.563c.552 0 1 .448 1 1s-.448 1-1 1h-4.563z"/></svg></a>。因此不建议用onnxruntime-gpu版推理。推荐用<a data-bs-delay="{&#34;hide&#34;:300,&#34;show&#34;:550}" data-bs-html="true" data-bs-title="<a href='/RapidOCRDocs/docs/install_usage/rapidocr_paddle/'><p>安装及使用</p><strong>[GPU端] rapidocr_paddle</strong><br></a>" data-bs-toggle="tooltip" href="/RapidOCRDocs/docs/install_usage/rapidocr_paddle/"><code>rapidocr_paddle</code></a></p>
+  <div class="w-100"><p>请使用Python3.6及以上版本。<br/> <code>rapidocr_onnxruntime</code>系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考<a href="https://rapidai.github.io/RapidOCRDocs/docs/inference_engine/onnxruntime/onnxruntime-gpu/" rel="external" target="_blank">link<svg width="16" height="16" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><path fill="currentColor" d="M14 5c-.552 0-1-.448-1-1s.448-1 1-1h6c.552 0 1 .448 1 1v6c0 .552-.448 1-1 1s-1-.448-1-1v-3.586l-7.293 7.293c-.391.39-1.024.39-1.414 0-.391-.391-.391-1.024 0-1.414l7.293-7.293h-3.586zm-9 2c-.552 0-1 .448-1 1v11c0 .552.448 1 1 1h11c.552 0 1-.448 1-1v-4.563c0-.552.448-1 1-1s1 .448 1 1v4.563c0 1.657-1.343 3-3 3h-11c-1.657 0-3-1.343-3-3v-11c0-1.657 1.343-3 3-3h4.563c.552 0 1 .448 1 1s-.448 1-1 1h-4.563z"/></svg></a>。因此不建议用<code>onnxruntime-gpu</code>版推理。<br/>GPU端推理推荐用<a data-bs-delay="{&#34;hide&#34;:300,&#34;show&#34;:550}" data-bs-html="true" data-bs-title="<a href='/RapidOCRDocs/docs/install_usage/rapidocr_paddle/'><p>安装及使用</p><strong>[GPU端] rapidocr_paddle</strong><br></a>" data-bs-toggle="tooltip" href="/RapidOCRDocs/docs/install_usage/rapidocr_paddle/"><code>rapidocr_paddle</code></a></p>
 </div>
   </div>
 
@@ -820,8 +820,11 @@ <h4 id="安装">安装 <a href="#%e5%ae%89%e8%a3%85" class="anchor" aria-hidden=
   
 
   <div class="prism-codeblock  linenos">
-  <pre id="7cd47f2" class="language-bash  line-numbers">
-  <code>pip install rapidocr-onnxruntime</code>
+  <pre id="b4e04b2" class="language-bash  line-numbers">
+  <code>pip install rapidocr-onnxruntime
+
+# 基于OpenVINO
+pip install rapidocr_openvino</code>
   </pre>
   </div>
 <p>安装速度慢的话，可以指定国内的安装源，如使用清华源：</p>
@@ -939,9 +942,9 @@ <h4 id="安装">安装 <a href="#%e5%ae%89%e8%a3%85" class="anchor" aria-hidden=
     <div id="last-modified" class="mt-1">
         <p class="mb-0 fw-semibold">Last updated <span
             id="relativetime"
-            data-authdate="2024-05-12T15:24:22&#43;0800"
-            title="12 May 2024, 15:24 &#43;0800">
-            12 May 2024, 15:24 &#43;0800
+            data-authdate="2024-05-19T09:29:25&#43;0800"
+            title="19 May 2024, 09:29 &#43;0800">
+            19 May 2024, 09:29 &#43;0800
         </span>. <span class="material-icons size-20 align-text-bottom opacity-75">history</span>
         </p>
     </div>
@@ -1581,7 +1584,7 @@ <h4 id="安装">安装 <a href="#%e5%ae%89%e8%a3%85" class="anchor" aria-hidden=
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1590,8 +1593,8 @@ <h4 id="安装">安装 <a href="#%e5%ae%89%e8%a3%85" class="anchor" aria-hidden=
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/install_usage/rapidocr/usage/index.html b/docs/install_usage/rapidocr/usage/index.html
index 4c13b237..4bde9636 100644
--- a/docs/install_usage/rapidocr/usage/index.html
+++ b/docs/install_usage/rapidocr/usage/index.html
@@ -33,21 +33,19 @@
 <link rel="icon" type="image/png" sizes="16x16" href="https://rapidai.github.io/RapidOCRDocs/favicon-16x16.png">
 <link rel="manifest" crossorigin="use-credentials" href="https://rapidai.github.io/RapidOCRDocs/site.webmanifest">
 <meta property="og:title" content="使用说明" />
-<meta property="og:description" content="初始化 link类RapidOCR是主类，其初始化函数如下：
+<meta property="og:description" content="初始化 linkRapidOCR类是主类，其初始化函数如下：
 class RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：
-以config.yaml方式
-找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=&#34;your.yaml&#34;) (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。
+以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=&#34;your.yaml&#34;) (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。
 info 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = &#34;min&#34;, det_thresh: float = 0." />
 <meta property="og:type" content="article" />
 <meta property="og:url" content="https://rapidai.github.io/RapidOCRDocs/docs/install_usage/rapidocr/usage/" /><meta property="og:image" content="https://rapidai.github.io/RapidOCRDocs/opengraph/card-base-2_hu06b1a92291a380a0d2e0ec03dab66b2f_17642_filter_17795501070310800273.png"/><meta property="article:section" content="docs" />
 
-<meta property="article:modified_time" content="2024-05-15T22:43:19+08:00" /><meta name="twitter:card" content="summary_large_image"/>
+<meta property="article:modified_time" content="2024-05-19T09:29:25+08:00" /><meta name="twitter:card" content="summary_large_image"/>
 <meta name="twitter:image" content="https://rapidai.github.io/RapidOCRDocs/opengraph/card-base-2_hu06b1a92291a380a0d2e0ec03dab66b2f_17642_filter_17795501070310800273.png"/>
 <meta name="twitter:title" content="使用说明"/>
-<meta name="twitter:description" content="初始化 link类RapidOCR是主类，其初始化函数如下：
+<meta name="twitter:description" content="初始化 linkRapidOCR类是主类，其初始化函数如下：
 class RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：
-以config.yaml方式
-找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=&#34;your.yaml&#34;) (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。
+以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=&#34;your.yaml&#34;) (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。
 info 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = &#34;min&#34;, det_thresh: float = 0."/>
 
     
@@ -672,10 +670,15 @@
       <ul>
         <li>
           <ul>
-            <li><a href="#初始化">初始化</a></li>
+            <li><a href="#初始化">初始化</a>
+              <ul>
+                <li><a href="#以configyaml方式">以<code>config.yaml</code>方式</a></li>
+                <li><a href="#推荐-以具体参数传入">(推荐) 以具体参数传入</a></li>
+              </ul>
+            </li>
             <li><a href="#输入">输入</a></li>
             <li><a href="#输出">输出</a></li>
-            <li><a href="#可视化查看结果">可视化查看结果</a></li>
+            <li><a href="#可视化查看">可视化查看</a></li>
           </ul>
         </li>
       </ul>
@@ -695,10 +698,15 @@
       <ul>
         <li>
           <ul>
-            <li><a href="#初始化">初始化</a></li>
+            <li><a href="#初始化">初始化</a>
+              <ul>
+                <li><a href="#以configyaml方式">以<code>config.yaml</code>方式</a></li>
+                <li><a href="#推荐-以具体参数传入">(推荐) 以具体参数传入</a></li>
+              </ul>
+            </li>
             <li><a href="#输入">输入</a></li>
             <li><a href="#输出">输出</a></li>
-            <li><a href="#可视化查看结果">可视化查看结果</a></li>
+            <li><a href="#可视化查看">可视化查看</a></li>
           </ul>
         </li>
       </ul>
@@ -720,7 +728,7 @@ <h1 class="content-title mb-0">
                                                 
     
     <div data-prismjs-copy="" data-prismjs-copy-success="" data-prismjs-copy-error="">
-        <h3 id="初始化">初始化 <a href="#%e5%88%9d%e5%a7%8b%e5%8c%96" class="anchor" aria-hidden="true"><i class="material-icons align-middle">link</i></a></h3><p>类<a href="https://github.com/RapidAI/RapidOCR/blob/a981e21743f03d9bbfbe596974123fecfe8a7d62/python/rapidocr_onnxruntime/main.py#L19" rel="external" target="_blank">RapidOCR<svg width="16" height="16" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><path fill="currentColor" d="M14 5c-.552 0-1-.448-1-1s.448-1 1-1h6c.552 0 1 .448 1 1v6c0 .552-.448 1-1 1s-1-.448-1-1v-3.586l-7.293 7.293c-.391.39-1.024.39-1.414 0-.391-.391-.391-1.024 0-1.414l7.293-7.293h-3.586zm-9 2c-.552 0-1 .448-1 1v11c0 .552.448 1 1 1h11c.552 0 1-.448 1-1v-4.563c0-.552.448-1 1-1s1 .448 1 1v4.563c0 1.657-1.343 3-3 3h-11c-1.657 0-3-1.343-3-3v-11c0-1.657 1.343-3 3-3h4.563c.552 0 1 .448 1 1s-.448 1-1 1h-4.563z"/></svg></a>是主类，其初始化函数如下：</p>
+        <h3 id="初始化">初始化 <a href="#%e5%88%9d%e5%a7%8b%e5%8c%96" class="anchor" aria-hidden="true"><i class="material-icons align-middle">link</i></a></h3><p><a href="https://github.com/RapidAI/RapidOCR/blob/a981e21743f03d9bbfbe596974123fecfe8a7d62/python/rapidocr_onnxruntime/main.py#L19" rel="external" target="_blank">RapidOCR<svg width="16" height="16" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><path fill="currentColor" d="M14 5c-.552 0-1-.448-1-1s.448-1 1-1h6c.552 0 1 .448 1 1v6c0 .552-.448 1-1 1s-1-.448-1-1v-3.586l-7.293 7.293c-.391.39-1.024.39-1.414 0-.391-.391-.391-1.024 0-1.414l7.293-7.293h-3.586zm-9 2c-.552 0-1 .448-1 1v11c0 .552.448 1 1 1h11c.552 0 1-.448 1-1v-4.563c0-.552.448-1 1-1s1 .448 1 1v4.563c0 1.657-1.343 3-3 3h-11c-1.657 0-3-1.343-3-3v-11c0-1.657 1.343-3 3-3h4.563c.552 0 1 .448 1 1s-.448 1-1 1h-4.563z"/></svg></a>类是主类，其初始化函数如下：</p>
 
 
 
@@ -746,10 +754,7 @@ <h3 id="初始化">初始化 <a href="#%e5%88%9d%e5%a7%8b%e5%8c%96" class="ancho
   </pre>
   </div>
 <p>支持两种自定义传参数的方案，下面分别详细说明：</p>
-<ul>
-<li>
-<p>以<code>config.yaml</code>方式</p>
-<ol>
+<h4 id="以configyaml方式">以<code>config.yaml</code>方式 <a href="#%e4%bb%a5configyaml%e6%96%b9%e5%bc%8f" class="anchor" aria-hidden="true"><i class="material-icons align-middle">link</i></a></h4><ol>
 <li>找到<code>rapidocr_onnxruntime</code>安装目录下的<code>config.yaml</code>文件，可以通过<code>pip show rapidocr_onnxruntime</code>找到其安装路径。</li>
 <li>将<code>config.yaml</code>拷贝出来，放到当前运行目录下</li>
 <li>按需自定义参数修改即可，具体参数解释，参见<a data-bs-delay="{&#34;hide&#34;:300,&#34;show&#34;:550}" data-bs-html="true" data-bs-title="<a href='/RapidOCRDocs/docs/blog/02_config_parameter/'><p>博客</p><strong>config.yaml参数解释</strong><br></a>" data-bs-toggle="tooltip" href="/RapidOCRDocs/docs/blog/02_config_parameter/">config.yaml</a>
@@ -777,9 +782,7 @@ <h3 id="初始化">初始化 <a href="#%e5%88%9d%e5%a7%8b%e5%8c%96" class="ancho
   </div>
 </li>
 </ol>
-</li>
-<li>
-<p>(推荐) 以具体参数传入，参数基本和<a data-bs-delay="{&#34;hide&#34;:300,&#34;show&#34;:550}" data-bs-html="true" data-bs-title="<a href='/RapidOCRDocs/docs/blog/02_config_parameter/'><p>博客</p><strong>config.yaml参数解释</strong><br></a>" data-bs-toggle="tooltip" href="/RapidOCRDocs/docs/blog/02_config_parameter/">config.yaml</a>中对应，只是个别名称有所区别。</p>
+<h4 id="推荐-以具体参数传入">(推荐) 以具体参数传入 <a href="#%e6%8e%a8%e8%8d%90-%e4%bb%a5%e5%85%b7%e4%bd%93%e5%8f%82%e6%95%b0%e4%bc%a0%e5%85%a5" class="anchor" aria-hidden="true"><i class="material-icons align-middle">link</i></a></h4><p>参数基本和<a data-bs-delay="{&#34;hide&#34;:300,&#34;show&#34;:550}" data-bs-html="true" data-bs-title="<a href='/RapidOCRDocs/docs/blog/02_config_parameter/'><p>博客</p><strong>config.yaml参数解释</strong><br></a>" data-bs-toggle="tooltip" href="/RapidOCRDocs/docs/blog/02_config_parameter/">config.yaml</a>中对应，只是个别名称有所区别。</p>
 
   <div class="alert alert-info d-flex" role="alert">
     <div class="flex-shrink-1 alert-icon">
@@ -788,7 +791,7 @@ <h3 id="初始化">初始化 <a href="#%e5%88%9d%e5%a7%8b%e5%8c%96" class="ancho
     info
     </span></div>
     
-    <div class="w-100">以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。<br/><code>intra_op_num_threads</code>和<code>inter_op_num_threads</code>仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码</div>
+    <div class="w-100">以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。<br/><code>intra_op_num_threads</code>和<code>inter_op_num_threads</code>仅是<code>rapidocr_onnxruntime</code>版本下的，其他推理引擎，请参见各自源码</div>
     </div>
 
 
@@ -848,8 +851,6 @@ <h3 id="初始化">初始化 <a href="#%e5%88%9d%e5%a7%8b%e5%8c%96" class="ancho
 res, elapse = engine(img, use_det=True, use_cls=True, use_rec=True)</code>
   </pre>
   </div>
-</li>
-</ul>
 <h3 id="输入">输入 <a href="#%e8%be%93%e5%85%a5" class="anchor" aria-hidden="true"><i class="material-icons align-middle">link</i></a></h3>
 <div class="alert alert-info d-flex" role="alert">
   <div class="flex-shrink-1 alert-icon">
@@ -873,32 +874,32 @@ <h3 id="输入">输入 <a href="#%e8%be%93%e5%85%a5" class="anchor" aria-hidden=
 		
 
 		<a class="nav-link  active"
-		   id="ecafdbTab" data-bs-toggle="tab" data-bs-target="#ecafdb"
-		   type="button" role="tab" aria-controls="ecafdb" aria-selected="true">str</a>
+		   id="daebfcTab" data-bs-toggle="tab" data-bs-target="#daebfc"
+		   type="button" role="tab" aria-controls="daebfc" aria-selected="true">str</a>
 
 		
 
 		<a class="nav-link "
-		   id="dcebafTab" data-bs-toggle="tab" data-bs-target="#dcebaf"
-		   type="button" role="tab" aria-controls="dcebaf" aria-selected="true">np.ndarray</a>
+		   id="dfebacTab" data-bs-toggle="tab" data-bs-target="#dfebac"
+		   type="button" role="tab" aria-controls="dfebac" aria-selected="true">np.ndarray</a>
 
 		
 
 		<a class="nav-link "
-		   id="adfcebTab" data-bs-toggle="tab" data-bs-target="#adfceb"
-		   type="button" role="tab" aria-controls="adfceb" aria-selected="true">PIL.Image.Image</a>
+		   id="fcdaebTab" data-bs-toggle="tab" data-bs-target="#fcdaeb"
+		   type="button" role="tab" aria-controls="fcdaeb" aria-selected="true">PIL.Image.Image</a>
 
 		
 
 		<a class="nav-link "
-		   id="aebdfcTab" data-bs-toggle="tab" data-bs-target="#aebdfc"
-		   type="button" role="tab" aria-controls="aebdfc" aria-selected="true">Bytes</a>
+		   id="fdcaebTab" data-bs-toggle="tab" data-bs-target="#fdcaeb"
+		   type="button" role="tab" aria-controls="fdcaeb" aria-selected="true">Bytes</a>
 
 		
 
 		<a class="nav-link "
-		   id="badcefTab" data-bs-toggle="tab" data-bs-target="#badcef"
-		   type="button" role="tab" aria-controls="badcef" aria-selected="true">Path</a>
+		   id="deabcfTab" data-bs-toggle="tab" data-bs-target="#deabcf"
+		   type="button" role="tab" aria-controls="deabcf" aria-selected="true">Path</a>
 
 		
 
@@ -914,7 +915,7 @@ <h3 id="输入">输入 <a href="#%e8%be%93%e5%85%a5" class="anchor" aria-hidden=
 
 
 
-<div class="tab-pane fade show active" id="ecafdb" role="tabpanel" aria-labelledby="nav-1">
+<div class="tab-pane fade show active" id="daebfc" role="tabpanel" aria-labelledby="nav-1">
 
 	
 
@@ -954,7 +955,7 @@ <h3 id="输入">输入 <a href="#%e8%be%93%e5%85%a5" class="anchor" aria-hidden=
 
 
 
-<div class="tab-pane fade" id="dcebaf" role="tabpanel" aria-labelledby="nav-1">
+<div class="tab-pane fade" id="dfebac" role="tabpanel" aria-labelledby="nav-1">
 
 	
 
@@ -994,7 +995,7 @@ <h3 id="输入">输入 <a href="#%e8%be%93%e5%85%a5" class="anchor" aria-hidden=
 
 
 
-<div class="tab-pane fade" id="adfceb" role="tabpanel" aria-labelledby="nav-1">
+<div class="tab-pane fade" id="fcdaeb" role="tabpanel" aria-labelledby="nav-1">
 
 	
 
@@ -1034,7 +1035,7 @@ <h3 id="输入">输入 <a href="#%e8%be%93%e5%85%a5" class="anchor" aria-hidden=
 
 
 
-<div class="tab-pane fade" id="aebdfc" role="tabpanel" aria-labelledby="nav-1">
+<div class="tab-pane fade" id="fdcaeb" role="tabpanel" aria-labelledby="nav-1">
 
 	
 
@@ -1076,7 +1077,7 @@ <h3 id="输入">输入 <a href="#%e8%be%93%e5%85%a5" class="anchor" aria-hidden=
 
 
 
-<div class="tab-pane fade" id="badcef" role="tabpanel" aria-labelledby="nav-1">
+<div class="tab-pane fade" id="deabcf" role="tabpanel" aria-labelledby="nav-1">
 
 	
 
@@ -1115,7 +1116,8 @@ <h3 id="输入">输入 <a href="#%e8%be%93%e5%85%a5" class="anchor" aria-hidden=
 
 
 </div>
-<h3 id="输出">输出 <a href="#%e8%be%93%e5%87%ba" class="anchor" aria-hidden="true"><i class="material-icons align-middle">link</i></a></h3><p>类RapidOCR在调用时，有三个参数<code>use_det | use_cls | use_rec</code>，可以控制是否使用检测、方向分类和识别这三部分。不同的参数，决定了不同的输出，如果图像中未检测到有效文字信息，则返回<code>Tupule[None, None]</code>。详细搭配如下：</p>
+<h3 id="输出">输出 <a href="#%e8%be%93%e5%87%ba" class="anchor" aria-hidden="true"><i class="material-icons align-middle">link</i></a></h3><p>RapidOCR在调用时，有三个参数<code>use_det | use_cls | use_rec</code>，可以控制是否使用检测、方向分类和识别这三部分，不同的参数决定了不同的输出。</p>
+<p>如果图像中未检测到有效文字信息，则返回<code>Tuple[None, None]</code>。详细搭配如下：</p>
 
 <nav>
 	<div class="nav nav-tabs" id="nav-tab" role="tablist">
@@ -1128,38 +1130,38 @@ <h3 id="输出">输出 <a href="#%e8%be%93%e5%87%ba" class="anchor" aria-hidden=
 		
 
 		<a class="nav-link  active"
-		   id="bfedacTab" data-bs-toggle="tab" data-bs-target="#bfedac"
-		   type="button" role="tab" aria-controls="bfedac" aria-selected="true">只有检测</a>
+		   id="ecbfadTab" data-bs-toggle="tab" data-bs-target="#ecbfad"
+		   type="button" role="tab" aria-controls="ecbfad" aria-selected="true">只有检测</a>
 
 		
 
 		<a class="nav-link "
-		   id="dbcfeaTab" data-bs-toggle="tab" data-bs-target="#dbcfea"
-		   type="button" role="tab" aria-controls="dbcfea" aria-selected="true">只有分类</a>
+		   id="ecabfdTab" data-bs-toggle="tab" data-bs-target="#ecabfd"
+		   type="button" role="tab" aria-controls="ecabfd" aria-selected="true">只有分类</a>
 
 		
 
 		<a class="nav-link "
-		   id="faebcdTab" data-bs-toggle="tab" data-bs-target="#faebcd"
-		   type="button" role="tab" aria-controls="faebcd" aria-selected="true">只有识别</a>
+		   id="efcadbTab" data-bs-toggle="tab" data-bs-target="#efcadb"
+		   type="button" role="tab" aria-controls="efcadb" aria-selected="true">只有识别</a>
 
 		
 
 		<a class="nav-link "
-		   id="cafebdTab" data-bs-toggle="tab" data-bs-target="#cafebd"
-		   type="button" role="tab" aria-controls="cafebd" aria-selected="true">检测 &#43; 识别</a>
+		   id="eacbfdTab" data-bs-toggle="tab" data-bs-target="#eacbfd"
+		   type="button" role="tab" aria-controls="eacbfd" aria-selected="true">检测 &#43; 识别</a>
 
 		
 
 		<a class="nav-link "
-		   id="dafecbTab" data-bs-toggle="tab" data-bs-target="#dafecb"
-		   type="button" role="tab" aria-controls="dafecb" aria-selected="true">分类 &#43; 识别</a>
+		   id="bdfcaeTab" data-bs-toggle="tab" data-bs-target="#bdfcae"
+		   type="button" role="tab" aria-controls="bdfcae" aria-selected="true">分类 &#43; 识别</a>
 
 		
 
 		<a class="nav-link "
-		   id="fdaebcTab" data-bs-toggle="tab" data-bs-target="#fdaebc"
-		   type="button" role="tab" aria-controls="fdaebc" aria-selected="true">检测 &#43; 分类 &#43; 识别</a>
+		   id="efcbdaTab" data-bs-toggle="tab" data-bs-target="#efcbda"
+		   type="button" role="tab" aria-controls="efcbda" aria-selected="true">检测 &#43; 分类 &#43; 识别</a>
 
 		
 
@@ -1175,7 +1177,7 @@ <h3 id="输出">输出 <a href="#%e8%be%93%e5%87%ba" class="anchor" aria-hidden=
 
 
 
-<div class="tab-pane fade show active" id="bfedac" role="tabpanel" aria-labelledby="nav-1">
+<div class="tab-pane fade show active" id="ecbfad" role="tabpanel" aria-labelledby="nav-1">
 
 	
 
@@ -1239,7 +1241,7 @@ <h3 id="输出">输出 <a href="#%e8%be%93%e5%87%ba" class="anchor" aria-hidden=
 
 
 
-<div class="tab-pane fade" id="dbcfea" role="tabpanel" aria-labelledby="nav-1">
+<div class="tab-pane fade" id="ecabfd" role="tabpanel" aria-labelledby="nav-1">
 
 	
 
@@ -1302,7 +1304,7 @@ <h3 id="输出">输出 <a href="#%e8%be%93%e5%87%ba" class="anchor" aria-hidden=
 
 
 
-<div class="tab-pane fade" id="faebcd" role="tabpanel" aria-labelledby="nav-1">
+<div class="tab-pane fade" id="efcadb" role="tabpanel" aria-labelledby="nav-1">
 
 	
 
@@ -1368,7 +1370,7 @@ <h3 id="输出">输出 <a href="#%e8%be%93%e5%87%ba" class="anchor" aria-hidden=
 
 
 
-<div class="tab-pane fade" id="cafebd" role="tabpanel" aria-labelledby="nav-1">
+<div class="tab-pane fade" id="eacbfd" role="tabpanel" aria-labelledby="nav-1">
 
 	
 
@@ -1435,7 +1437,7 @@ <h3 id="输出">输出 <a href="#%e8%be%93%e5%87%ba" class="anchor" aria-hidden=
 
 
 
-<div class="tab-pane fade" id="dafecb" role="tabpanel" aria-labelledby="nav-1">
+<div class="tab-pane fade" id="bdfcae" role="tabpanel" aria-labelledby="nav-1">
 
 	
 
@@ -1501,7 +1503,7 @@ <h3 id="输出">输出 <a href="#%e8%be%93%e5%87%ba" class="anchor" aria-hidden=
 
 
 
-<div class="tab-pane fade" id="fdaebc" role="tabpanel" aria-labelledby="nav-1">
+<div class="tab-pane fade" id="efcbda" role="tabpanel" aria-labelledby="nav-1">
 
 	
 
@@ -1567,7 +1569,7 @@ <h3 id="输出">输出 <a href="#%e8%be%93%e5%87%ba" class="anchor" aria-hidden=
 
 
 </div>
-<h3 id="可视化查看结果">可视化查看结果 <a href="#%e5%8f%af%e8%a7%86%e5%8c%96%e6%9f%a5%e7%9c%8b%e7%bb%93%e6%9e%9c" class="anchor" aria-hidden="true"><i class="material-icons align-middle">link</i></a></h3><p>为了便于查看检测和识别结果，该库中封装了<a href="https://github.com/RapidAI/RapidOCR/blob/a981e21743f03d9bbfbe596974123fecfe8a7d62/python/rapidocr_onnxruntime/utils.py#L351" rel="external" target="_blank"><code>VisRes</code><svg width="16" height="16" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><path fill="currentColor" d="M14 5c-.552 0-1-.448-1-1s.448-1 1-1h6c.552 0 1 .448 1 1v6c0 .552-.448 1-1 1s-1-.448-1-1v-3.586l-7.293 7.293c-.391.39-1.024.39-1.414 0-.391-.391-.391-1.024 0-1.414l7.293-7.293h-3.586zm-9 2c-.552 0-1 .448-1 1v11c0 .552.448 1 1 1h11c.552 0 1-.448 1-1v-4.563c0-.552.448-1 1-1s1 .448 1 1v4.563c0 1.657-1.343 3-3 3h-11c-1.657 0-3-1.343-3-3v-11c0-1.657 1.343-3 3-3h4.563c.552 0 1 .448 1 1s-.448 1-1 1h-4.563z"/></svg></a>类，可借助该类快速可视化查看结果。</p>
+<h3 id="可视化查看">可视化查看 <a href="#%e5%8f%af%e8%a7%86%e5%8c%96%e6%9f%a5%e7%9c%8b" class="anchor" aria-hidden="true"><i class="material-icons align-middle">link</i></a></h3><p>为了便于查看检测和识别结果，该库中封装了<a href="https://github.com/RapidAI/RapidOCR/blob/a981e21743f03d9bbfbe596974123fecfe8a7d62/python/rapidocr_onnxruntime/utils.py#L351" rel="external" target="_blank"><code>VisRes</code><svg width="16" height="16" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><path fill="currentColor" d="M14 5c-.552 0-1-.448-1-1s.448-1 1-1h6c.552 0 1 .448 1 1v6c0 .552-.448 1-1 1s-1-.448-1-1v-3.586l-7.293 7.293c-.391.39-1.024.39-1.414 0-.391-.391-.391-1.024 0-1.414l7.293-7.293h-3.586zm-9 2c-.552 0-1 .448-1 1v11c0 .552.448 1 1 1h11c.552 0 1-.448 1-1v-4.563c0-.552.448-1 1-1s1 .448 1 1v4.563c0 1.657-1.343 3-3 3h-11c-1.657 0-3-1.343-3-3v-11c0-1.657 1.343-3 3-3h4.563c.552 0 1 .448 1 1s-.448 1-1 1h-4.563z"/></svg></a>类，可借助该类快速可视化查看结果。</p>
 
 <div class="alert alert-info d-flex" role="alert">
   <div class="flex-shrink-1 alert-icon">
@@ -1591,14 +1593,14 @@ <h3 id="可视化查看结果">可视化查看结果 <a href="#%e5%8f%af%e8%a7%8
 		
 
 		<a class="nav-link  active"
-		   id="edbcfaTab" data-bs-toggle="tab" data-bs-target="#edbcfa"
-		   type="button" role="tab" aria-controls="edbcfa" aria-selected="true">只可视化检测</a>
+		   id="ebfadcTab" data-bs-toggle="tab" data-bs-target="#ebfadc"
+		   type="button" role="tab" aria-controls="ebfadc" aria-selected="true">只可视化检测</a>
 
 		
 
 		<a class="nav-link "
-		   id="bcafdeTab" data-bs-toggle="tab" data-bs-target="#bcafde"
-		   type="button" role="tab" aria-controls="bcafde" aria-selected="true">可视化检测和识别</a>
+		   id="afdebcTab" data-bs-toggle="tab" data-bs-target="#afdebc"
+		   type="button" role="tab" aria-controls="afdebc" aria-selected="true">可视化检测和识别</a>
 
 		
 
@@ -1614,7 +1616,7 @@ <h3 id="可视化查看结果">可视化查看结果 <a href="#%e5%8f%af%e8%a7%8
 
 
 
-<div class="tab-pane fade show active" id="edbcfa" role="tabpanel" aria-labelledby="nav-1">
+<div class="tab-pane fade show active" id="ebfadc" role="tabpanel" aria-labelledby="nav-1">
 
 	
 
@@ -1660,7 +1662,7 @@ <h3 id="可视化查看结果">可视化查看结果 <a href="#%e5%8f%af%e8%a7%8
 
 
 
-<div class="tab-pane fade" id="bcafde" role="tabpanel" aria-labelledby="nav-1">
+<div class="tab-pane fade" id="afdebc" role="tabpanel" aria-labelledby="nav-1">
 
 	
 
@@ -1757,9 +1759,9 @@ <h3 id="可视化查看结果">可视化查看结果 <a href="#%e5%8f%af%e8%a7%8
     <div id="last-modified" class="mt-1">
         <p class="mb-0 fw-semibold">Last updated <span
             id="relativetime"
-            data-authdate="2024-05-15T22:43:19&#43;0800"
-            title="15 May 2024, 22:43 &#43;0800">
-            15 May 2024, 22:43 &#43;0800
+            data-authdate="2024-05-19T09:29:25&#43;0800"
+            title="19 May 2024, 09:29 &#43;0800">
+            19 May 2024, 09:29 &#43;0800
         </span>. <span class="material-icons size-20 align-text-bottom opacity-75">history</span>
         </p>
     </div>
@@ -2399,7 +2401,7 @@ <h3 id="可视化查看结果">可视化查看结果 <a href="#%e5%8f%af%e8%a7%8
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -2408,8 +2410,8 @@ <h3 id="可视化查看结果">可视化查看结果 <a href="#%e5%8f%af%e8%a7%8
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/install_usage/rapidocr_api/index.html b/docs/install_usage/rapidocr_api/index.html
index 2be40ea4..f10c8960 100644
--- a/docs/install_usage/rapidocr_api/index.html
+++ b/docs/install_usage/rapidocr_api/index.html
@@ -848,14 +848,14 @@ <h4 id="python调用">Python调用 <a href="#python%e8%b0%83%e7%94%a8" class="an
 		
 
 		<a class="nav-link  active"
-		   id="acbdfeTab" data-bs-toggle="tab" data-bs-target="#acbdfe"
-		   type="button" role="tab" aria-controls="acbdfe" aria-selected="true">以文件方式发送POST请求</a>
+		   id="ecafbdTab" data-bs-toggle="tab" data-bs-target="#ecafbd"
+		   type="button" role="tab" aria-controls="ecafbd" aria-selected="true">以文件方式发送POST请求</a>
 
 		
 
 		<a class="nav-link "
-		   id="dcfabeTab" data-bs-toggle="tab" data-bs-target="#dcfabe"
-		   type="button" role="tab" aria-controls="dcfabe" aria-selected="true">以base64方式发送POST请求</a>
+		   id="cdebfaTab" data-bs-toggle="tab" data-bs-target="#cdebfa"
+		   type="button" role="tab" aria-controls="cdebfa" aria-selected="true">以base64方式发送POST请求</a>
 
 		
 
@@ -871,7 +871,7 @@ <h4 id="python调用">Python调用 <a href="#python%e8%b0%83%e7%94%a8" class="an
 
 
 
-<div class="tab-pane fade show active" id="acbdfe" role="tabpanel" aria-labelledby="nav-1">
+<div class="tab-pane fade show active" id="ecafbd" role="tabpanel" aria-labelledby="nav-1">
 
 	
 
@@ -913,7 +913,7 @@ <h4 id="python调用">Python调用 <a href="#python%e8%b0%83%e7%94%a8" class="an
 
 
 
-<div class="tab-pane fade" id="dcfabe" role="tabpanel" aria-labelledby="nav-1">
+<div class="tab-pane fade" id="cdebfa" role="tabpanel" aria-labelledby="nav-1">
 
 	
 
@@ -1766,7 +1766,7 @@ <h3 id="api输出">API输出 <a href="#api%e8%be%93%e5%87%ba" class="anchor" ari
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1775,8 +1775,8 @@ <h3 id="api输出">API输出 <a href="#api%e8%be%93%e5%87%ba" class="anchor" ari
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/install_usage/rapidocr_paddle/index.html b/docs/install_usage/rapidocr_paddle/index.html
index f2aeb35c..ea6c64ac 100644
--- a/docs/install_usage/rapidocr_paddle/index.html
+++ b/docs/install_usage/rapidocr_paddle/index.html
@@ -798,14 +798,14 @@ <h4 id="使用">使用 <a href="#%e4%bd%bf%e7%94%a8" class="anchor" aria-hidden=
 		
 
 		<a class="nav-link  active"
-		   id="fabcdeTab" data-bs-toggle="tab" data-bs-target="#fabcde"
-		   type="button" role="tab" aria-controls="fabcde" aria-selected="true">CPU端推理</a>
+		   id="aecbfdTab" data-bs-toggle="tab" data-bs-target="#aecbfd"
+		   type="button" role="tab" aria-controls="aecbfd" aria-selected="true">CPU端推理</a>
 
 		
 
 		<a class="nav-link "
-		   id="caedfbTab" data-bs-toggle="tab" data-bs-target="#caedfb"
-		   type="button" role="tab" aria-controls="caedfb" aria-selected="true">GPU端推理</a>
+		   id="febadcTab" data-bs-toggle="tab" data-bs-target="#febadc"
+		   type="button" role="tab" aria-controls="febadc" aria-selected="true">GPU端推理</a>
 
 		
 
@@ -821,7 +821,7 @@ <h4 id="使用">使用 <a href="#%e4%bd%bf%e7%94%a8" class="anchor" aria-hidden=
 
 
 
-<div class="tab-pane fade show active" id="fabcde" role="tabpanel" aria-labelledby="nav-1">
+<div class="tab-pane fade show active" id="aecbfd" role="tabpanel" aria-labelledby="nav-1">
 
 	<p>前提是安装了CPU版的PaddlePaddle</p>
 
@@ -864,7 +864,7 @@ <h4 id="使用">使用 <a href="#%e4%bd%bf%e7%94%a8" class="anchor" aria-hidden=
 
 
 
-<div class="tab-pane fade" id="caedfb" role="tabpanel" aria-labelledby="nav-1">
+<div class="tab-pane fade" id="febadc" role="tabpanel" aria-labelledby="nav-1">
 
 	<p>前提是安装了GPU版的PaddlePaddle，注意在实例化<code>RapidOCR</code>类时，需要通过参数显式指定使用GPU。</p>
 
@@ -1631,7 +1631,7 @@ <h4 id="推理速度比较">推理速度比较 <a href="#%e6%8e%a8%e7%90%86%e9%8
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1640,8 +1640,8 @@ <h4 id="推理速度比较">推理速度比较 <a href="#%e6%8e%a8%e7%90%86%e9%8
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/install_usage/rapidocr_web/desktop_usage/index.html b/docs/install_usage/rapidocr_web/desktop_usage/index.html
index e3ddb2a8..4ee4878c 100644
--- a/docs/install_usage/rapidocr_web/desktop_usage/index.html
+++ b/docs/install_usage/rapidocr_web/desktop_usage/index.html
@@ -1603,7 +1603,7 @@ <h4 id="使用步骤">使用步骤 <a href="#%e4%bd%bf%e7%94%a8%e6%ad%a5%e9%aa%a
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1612,8 +1612,8 @@ <h4 id="使用步骤">使用步骤 <a href="#%e4%bd%bf%e7%94%a8%e6%ad%a5%e9%aa%a
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/install_usage/rapidocr_web/index.html b/docs/install_usage/rapidocr_web/index.html
index ecc294c9..5f703657 100644
--- a/docs/install_usage/rapidocr_web/index.html
+++ b/docs/install_usage/rapidocr_web/index.html
@@ -1364,7 +1364,7 @@ <h1 class="content-title mb-0">
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1373,8 +1373,8 @@ <h1 class="content-title mb-0">
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/install_usage/rapidocr_web/nuitka_package/index.html b/docs/install_usage/rapidocr_web/nuitka_package/index.html
index 7374efcc..6eabfd65 100644
--- a/docs/install_usage/rapidocr_web/nuitka_package/index.html
+++ b/docs/install_usage/rapidocr_web/nuitka_package/index.html
@@ -1619,7 +1619,7 @@ <h4 id="补充">补充 <a href="#%e8%a1%a5%e5%85%85" class="anchor" aria-hidden=
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1628,8 +1628,8 @@ <h4 id="补充">补充 <a href="#%e8%a1%a5%e5%85%85" class="anchor" aria-hidden=
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/install_usage/rapidocr_web/ocrweb_multi/index.html b/docs/install_usage/rapidocr_web/ocrweb_multi/index.html
index 22de181c..c6adad9f 100644
--- a/docs/install_usage/rapidocr_web/ocrweb_multi/index.html
+++ b/docs/install_usage/rapidocr_web/ocrweb_multi/index.html
@@ -1574,7 +1574,7 @@ <h3 id="运行步骤">运行步骤 <a href="#%e8%bf%90%e8%a1%8c%e6%ad%a5%e9%aa%a
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1583,8 +1583,8 @@ <h3 id="运行步骤">运行步骤 <a href="#%e8%bf%90%e8%a1%8c%e6%ad%a5%e9%aa%a
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/install_usage/rapidocr_web/pyinstaller/index.html b/docs/install_usage/rapidocr_web/pyinstaller/index.html
index 6185e2c1..d727e517 100644
--- a/docs/install_usage/rapidocr_web/pyinstaller/index.html
+++ b/docs/install_usage/rapidocr_web/pyinstaller/index.html
@@ -1377,7 +1377,7 @@ <h1 class="content-title mb-0">
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1386,8 +1386,8 @@ <h1 class="content-title mb-0">
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/install_usage/rapidocr_web/rapidocr_web/index.html b/docs/install_usage/rapidocr_web/rapidocr_web/index.html
index 50368a9d..a8e80484 100644
--- a/docs/install_usage/rapidocr_web/rapidocr_web/index.html
+++ b/docs/install_usage/rapidocr_web/rapidocr_web/index.html
@@ -1520,7 +1520,7 @@ <h3 id="使用">使用 <a href="#%e4%bd%bf%e7%94%a8" class="anchor" aria-hidden=
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1529,8 +1529,8 @@ <h3 id="使用">使用 <a href="#%e4%bd%bf%e7%94%a8" class="anchor" aria-hidden=
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/online_demo/index.html b/docs/online_demo/index.html
index 9f26cc88..50d204c1 100644
--- a/docs/online_demo/index.html
+++ b/docs/online_demo/index.html
@@ -1423,7 +1423,7 @@ <h4 id="在线demo">在线Demo <a href="#%e5%9c%a8%e7%ba%bfdemo" class="anchor"
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1432,8 +1432,8 @@ <h4 id="在线demo">在线Demo <a href="#%e5%9c%a8%e7%ba%bfdemo" class="anchor"
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/other_programing_lan/index.html b/docs/other_programing_lan/index.html
index e131a431..8d14ef08 100644
--- a/docs/other_programing_lan/index.html
+++ b/docs/other_programing_lan/index.html
@@ -1419,7 +1419,7 @@ <h4 id="net范例chttpsgithubcomrapidairapidocrcsharp"><a href="https://github.c
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1428,8 +1428,8 @@ <h4 id="net范例chttpsgithubcomrapidairapidocrcsharp"><a href="https://github.c
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/overview/index.html b/docs/overview/index.html
index a4aaba9e..13fbabbb 100644
--- a/docs/overview/index.html
+++ b/docs/overview/index.html
@@ -1458,7 +1458,7 @@ <h3 id="相关产品概览图">相关产品概览图 <a href="#%e7%9b%b8%e5%85%b
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1467,8 +1467,8 @@ <h3 id="相关产品概览图">相关产品概览图 <a href="#%e7%9b%b8%e5%85%b
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/quickstart/index.html b/docs/quickstart/index.html
index 49af5266..e73f9623 100644
--- a/docs/quickstart/index.html
+++ b/docs/quickstart/index.html
@@ -729,14 +729,14 @@ <h3 id="2-使用">2. 使用 <a href="#2-%e4%bd%bf%e7%94%a8" class="anchor" aria-
 		
 
 		<a class="nav-link  active"
-		   id="caedfbTab" data-bs-toggle="tab" data-bs-target="#caedfb"
-		   type="button" role="tab" aria-controls="caedfb" aria-selected="true">终端使用</a>
+		   id="aedcbfTab" data-bs-toggle="tab" data-bs-target="#aedcbf"
+		   type="button" role="tab" aria-controls="aedcbf" aria-selected="true">终端使用</a>
 
 		
 
 		<a class="nav-link "
-		   id="efbdcaTab" data-bs-toggle="tab" data-bs-target="#efbdca"
-		   type="button" role="tab" aria-controls="efbdca" aria-selected="true">Python使用</a>
+		   id="fabedcTab" data-bs-toggle="tab" data-bs-target="#fabedc"
+		   type="button" role="tab" aria-controls="fabedc" aria-selected="true">Python使用</a>
 
 		
 
@@ -752,7 +752,7 @@ <h3 id="2-使用">2. 使用 <a href="#2-%e4%bd%bf%e7%94%a8" class="anchor" aria-
 
 
 
-<div class="tab-pane fade show active" id="caedfb" role="tabpanel" aria-labelledby="nav-1">
+<div class="tab-pane fade show active" id="aedcbf" role="tabpanel" aria-labelledby="nav-1">
 
 	
 
@@ -785,7 +785,7 @@ <h3 id="2-使用">2. 使用 <a href="#2-%e4%bd%bf%e7%94%a8" class="anchor" aria-
 
 
 
-<div class="tab-pane fade" id="efbdca" role="tabpanel" aria-labelledby="nav-1">
+<div class="tab-pane fade" id="fabedc" role="tabpanel" aria-labelledby="nav-1">
 
 	
 
@@ -1555,7 +1555,7 @@ <h3 id="3-查看效果">3. 查看效果 <a href="#3-%e6%9f%a5%e7%9c%8b%e6%95%88%
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1564,8 +1564,8 @@ <h3 id="3-查看效果">3. 查看效果 <a href="#3-%e6%9f%a5%e7%9c%8b%e6%95%88%
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/related_projects/derivatives_projects/index.html b/docs/related_projects/derivatives_projects/index.html
index c92159ff..76f18295 100644
--- a/docs/related_projects/derivatives_projects/index.html
+++ b/docs/related_projects/derivatives_projects/index.html
@@ -1415,7 +1415,7 @@ <h4 id="rapidocrserverhttpsgithubcomphystonrapidocrserverrapidocr-http服务win3
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1424,8 +1424,8 @@ <h4 id="rapidocrserverhttpsgithubcomphystonrapidocrserverrapidocr-http服务win3
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/related_projects/index.html b/docs/related_projects/index.html
index 232ce4a9..cbe75bae 100644
--- a/docs/related_projects/index.html
+++ b/docs/related_projects/index.html
@@ -1305,7 +1305,7 @@ <h1 class="content-title mb-0">
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1314,8 +1314,8 @@ <h1 class="content-title mb-0">
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/related_projects/related_projects/index.html b/docs/related_projects/related_projects/index.html
index f232db35..a85e38a3 100644
--- a/docs/related_projects/related_projects/index.html
+++ b/docs/related_projects/related_projects/index.html
@@ -1576,7 +1576,7 @@ <h3 id="印章ocr">印章OCR <a href="#%e5%8d%b0%e7%ab%a0ocr" class="anchor" ari
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1585,8 +1585,8 @@ <h3 id="印章ocr">印章OCR <a href="#%e5%8d%b0%e7%ab%a0ocr" class="anchor" ari
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/docs/sponsor/index.html b/docs/sponsor/index.html
index f49777f3..755d0316 100644
--- a/docs/sponsor/index.html
+++ b/docs/sponsor/index.html
@@ -1418,7 +1418,7 @@ <h4 id="buy-me-a-coffee">Buy me a Coffee <a href="#buy-me-a-coffee" class="ancho
                 id:  9 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/install\/",
                 title: "安装",
-                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
+                description: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例 如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。 版本情况 link各个库的最新版本： 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系： 版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。 notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源： pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下： info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper\u003e=1.2.1 onnxruntime\u003e=1.7.0 opencv_python\u003e=4.5.1.48 numpy\u003e=1.19.3 six\u003e=1.15.0 Shapely\u003e=1.7.1 PyYAML Pillow ",
                 content: " 简介 linkrapidocr_onnxruntime和rapidocr_openvino两个包除推理引擎不同之外，其余均相同。后续说明文档均以rapidocr_onnxruntime为例\n如使用rapidocr_openvino，直接更换关键词rapidocr_onnxruntime为rapidocr_openvino即可。\n两者均是在CPU上推理的，如想在GPU上推理，可以参考"
             }
         );
@@ -1427,8 +1427,8 @@ <h4 id="buy-me-a-coffee">Buy me a Coffee <a href="#buy-me-a-coffee" class="ancho
                 id:  10 ,
                 href: "\/RapidOCRDocs\/docs\/install_usage\/rapidocr\/usage\/",
                 title: "使用说明",
-                description: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
-                content: "初始化 link类RapidOCR是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式\n找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
+                description: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=\"your.yaml\") (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。\ninfo 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = \"min\", det_thresh: float = 0.",
+                content: "初始化 linkRapidOCR类是主类，其初始化函数如下：\nclass RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：\n以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见"
             }
         );
     index.add(
diff --git a/index.xml b/index.xml
index cb73d35f..993371fa 100644
--- a/index.xml
+++ b/index.xml
@@ -78,9 +78,9 @@ import cv2 from rapidocr_paddle import RapidOCR # 注意这里的参数 engine =
 两者均是在CPU上推理的，如想在GPU上推理，可以参考rapidocr_paddle版。
 版本情况 link各个库的最新版本：
 库 pypi最新版本 rapidocr_onnxruntime rapidocr_openvino rapidocr_paddle pypi上各个版本的对应关系：
-版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型。因为mobile版模型较小，因此将相关模型都已打到Whl包，可直接pip安装使用。
-notifications 请使用Python3.6及以上版本。 rapidocr系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。推荐用rapidocr_paddle
-pip install rapidocr-onnxruntime 安装速度慢的话，可以指定国内的安装源，如使用清华源：
+版本 内置模型版本 对应PaddleOCR 分支 v1.3.x PaddleOCR v4版 release/2.7 v1.2.xv1.1.xv1.0.x PaddleOCR v3版 release/2.6 安装 link顺利的话，一行命令即可。包大小约为14M左右，包含了三个模型（文本检测、文本行方向分类和文本识别）。因为其中mobile版模型较小，因此将相关模型都已打到whl包，可直接pip安装使用。
+notifications 请使用Python3.6及以上版本。 rapidocr_onnxruntime系列库目前仅在CPU上支持较好，GPU上推理很慢，这一点可参考link。因此不建议用onnxruntime-gpu版推理。GPU端推理推荐用rapidocr_paddle
+pip install rapidocr-onnxruntime # 基于OpenVINO pip install rapidocr_openvino 安装速度慢的话，可以指定国内的安装源，如使用清华源：
 pip install rapidocr_onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple/ 依赖的包如下：
 info 如果在安装过程中，出现某个依赖包不能正确安装时，可先单独安装某个依赖包，之后再安装rapidocr_onnxruntime即可。 pyclipper&amp;gt;=1.2.1 onnxruntime&amp;gt;=1.7.0 opencv_python&amp;gt;=4.5.1.48 numpy&amp;gt;=1.19.3 six&amp;gt;=1.15.0 Shapely&amp;gt;=1.7.1 PyYAML Pillow </description>
     </item>
@@ -91,10 +91,9 @@ info 如果在安装过程中，出现某个依赖包不能正确安装时，可
       <pubDate>Tue, 30 Aug 2022 15:39:03 +0100</pubDate>
       
       <guid>https://rapidai.github.io/RapidOCRDocs/docs/install_usage/rapidocr/usage/</guid>
-      <description>初始化 link类RapidOCR是主类，其初始化函数如下：
+      <description>初始化 linkRapidOCR类是主类，其初始化函数如下：
 class RapidOCR: def __init__(self, config_path: Optional[str] = None, **kwargs): pass 支持两种自定义传参数的方案，下面分别详细说明：
-以config.yaml方式
-找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=&amp;#34;your.yaml&amp;#34;) (推荐) 以具体参数传入，参数基本和config.yaml中对应，只是个别名称有所区别。
+以config.yaml方式 link 找到rapidocr_onnxruntime安装目录下的config.yaml文件，可以通过pip show rapidocr_onnxruntime找到其安装路径。 将config.yaml拷贝出来，放到当前运行目录下 按需自定义参数修改即可，具体参数解释，参见config.yaml engine = RapidOCR(config_path=&amp;#34;your.yaml&amp;#34;) (推荐) 以具体参数传入 link参数基本和config.yaml中对应，只是个别名称有所区别。
 info 以下参数均有默认值，可以不传入任何参数，直接初始化使用即可。intra_op_num_threads和inter_op_num_threads仅是rapidocr_onnxruntime版本下的，其他推理引擎，请参见各自源码 class RapidOCR: def __init__( self, text_score: float = 0.5, print_verbose: bool = False, min_height: int = 30, width_height_ratio: float = 8, det_use_cuda: bool = False, det_use_dml: bool = False, det_model_path: Optional[str] = None, det_limit_side_len: float = 736, det_limit_type: str = &amp;#34;min&amp;#34;, det_thresh: float = 0.</description>
     </item>
     
diff --git a/sitemap.xml b/sitemap.xml
index a509dd77..0e8c4cd7 100644
--- a/sitemap.xml
+++ b/sitemap.xml
@@ -30,10 +30,10 @@
     <lastmod>2024-05-12T15:24:22+08:00</lastmod>
   </url><url>
     <loc>https://rapidai.github.io/RapidOCRDocs/docs/install_usage/rapidocr/install/</loc>
-    <lastmod>2024-05-12T15:24:22+08:00</lastmod>
+    <lastmod>2024-05-19T09:29:25+08:00</lastmod>
   </url><url>
     <loc>https://rapidai.github.io/RapidOCRDocs/docs/install_usage/rapidocr/usage/</loc>
-    <lastmod>2024-05-15T22:43:19+08:00</lastmod>
+    <lastmod>2024-05-19T09:29:25+08:00</lastmod>
   </url><url>
     <loc>https://rapidai.github.io/RapidOCRDocs/docs/install_usage/rapidocr/cli/</loc>
     <lastmod>2024-04-24T09:27:46+08:00</lastmod>
@@ -153,7 +153,7 @@
     <lastmod>2024-05-12T15:24:22+08:00</lastmod>
   </url><url>
     <loc>https://rapidai.github.io/RapidOCRDocs/</loc>
-    <lastmod>2024-05-18T16:55:54+08:00</lastmod>
+    <lastmod>2024-05-19T09:29:25+08:00</lastmod>
   </url><url>
     <loc>https://rapidai.github.io/RapidOCRDocs/categories/</loc>
   </url><url>