paddlex 3.0.0b2__py3-none-any.whl → 3.0.0rc1__py3-none-any.whl

paddlex/paddlex_cli.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,39 +12,30 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os
 import argparse
+import ast
+import importlib.resources
+import os
+import shutil
 import subprocess
 import sys
-import tempfile
+from pathlib import Path
 
 from . import create_pipeline
-from .inference.pipelines import create_pipeline_from_config, load_pipeline_config
-from .repo_manager import setup, get_all_supported_repo_names
+from .constants import MODEL_FILE_PREFIX
+from .inference.pipelines import load_pipeline_config
+from .inference.utils.model_paths import get_model_paths
+from .repo_manager import get_all_supported_repo_names, setup
 from .utils import logging
+from .utils.deps import (
+    get_paddle2onnx_spec,
+    get_serving_dep_specs,
+    require_paddle2onnx_plugin,
+)
+from .utils.env import get_paddle_cuda_version
+from .utils.install import install_packages
 from .utils.interactive_get_pipeline import interactive_get_pipeline
-
-
-def _install_serving_deps():
-    SERVING_DEPS = [
-        "aiohttp>=3.9",
-        "bce-python-sdk>=0.8",
-        "fastapi>=0.110",
-        "pydantic>=2",
-        "starlette>=0.36",
-        "typing_extensions>=4.11",
-        "uvicorn>=0.16",
-        "yarl>=1.9",
-    ]
-    with tempfile.TemporaryDirectory() as td:
-        req_file = os.path.join(td, "requirements.txt")
-        with open(req_file, "w", encoding="utf-8") as f:
-            for dep in SERVING_DEPS:
-                f.write(dep + "\n")
-            f.flush()
-        return subprocess.check_call(
-            [sys.executable, "-m", "pip", "install", "-r", req_file]
-        )
+from .utils.pipeline_arguments import PIPELINE_ARGUMENTS
 
 
 def args_cfg():
@@ -55,7 +46,7 @@ def args_cfg():
         to None type if it is "None",
         to bool type if it means True or False.
         """
-        if s in ("None"):
+        if s in ("None", "none", "NONE"):
             return None
         elif s in ("TRUE", "True", "true", "T", "t"):
             return True
@@ -63,47 +54,210 @@ def args_cfg():
             return False
         return s
 
-    parser = argparse.ArgumentParser()
+    parser = argparse.ArgumentParser(
+        "Command-line interface for PaddleX. Use the options below to install plugins, run pipeline predictions, or start the serving application."
+    )
+
+    install_group = parser.add_argument_group("Install PaddleX Options")
+    pipeline_group = parser.add_argument_group("Pipeline Predict Options")
+    serving_group = parser.add_argument_group("Serving Options")
+    paddle2onnx_group = parser.add_argument_group("Paddle2ONNX Options")
 
     ################# install pdx #################
-    parser.add_argument("--install", action="store_true", default=False, help="")
-    parser.add_argument("plugins", nargs="*", default=[])
-    parser.add_argument("--no_deps", action="store_true")
-    parser.add_argument("--platform", type=str, default="github.com")
-    parser.add_argument(
+    install_group.add_argument(
+        "--install",
+        action="store_true",
+        default=False,
+        help="Install specified PaddleX plugins.",
+    )
+    install_group.add_argument(
+        "plugins",
+        nargs="*",
+        default=[],
+        help="Names of custom development plugins to install (space-separated).",
+    )
+    install_group.add_argument(
+        "--no_deps",
+        action="store_true",
+        help="Install custom development plugins without their dependencies.",
+    )
+    install_group.add_argument(
+        "--platform",
+        type=str,
+        choices=["github.com", "gitee.com"],
+        default="github.com",
+        help="Platform to use for installation (default: github.com).",
+    )
+    install_group.add_argument(
         "-y",
         "--yes",
         dest="update_repos",
         action="store_true",
-        help="Whether to update_repos all packages.",
+        help="Automatically confirm prompts and update repositories.",
     )
-    parser.add_argument(
+    install_group.add_argument(
         "--use_local_repos",
         action="store_true",
         default=False,
-        help="Use local repos when existing.",
+        help="Use local repositories if they exist.",
+    )
+    install_group.add_argument(
+        "--deps_to_replace",
+        type=str,
+        nargs="+",
+        default=None,
+        help="Replace dependency version when installing from repositories.",
     )
 
     ################# pipeline predict #################
-    parser.add_argument("--pipeline", type=str, help="")
-    parser.add_argument("--input", type=str, default=None, help="")
-    parser.add_argument("--save_path", type=str, default=None, help="")
-    parser.add_argument("--device", type=str, default=None, help="")
-    parser.add_argument("--use_hpip", action="store_true")
-    parser.add_argument("--serial_number", type=str)
-    parser.add_argument("--update_license", action="store_true")
-    parser.add_argument("--get_pipeline_config", type=str, default=None, help="")
+    pipeline_group.add_argument(
+        "--pipeline", type=str, help="Name of the pipeline to execute for prediction."
+    )
+    pipeline_group.add_argument(
+        "--input",
+        type=str,
+        default=None,
+        help="Input data or path for the pipeline, supports specific file and directory.",
+    )
+    pipeline_group.add_argument(
+        "--save_path",
+        type=str,
+        default=None,
+        help="Path to save the prediction results.",
+    )
+    pipeline_group.add_argument(
+        "--device",
+        type=str,
+        default=None,
+        help="Device to run the pipeline on (e.g., 'cpu', 'gpu:0').",
+    )
+    pipeline_group.add_argument(
+        "--use_hpip",
+        action="store_true",
+        help="Use high-performance inference plugin.",
+    )
+    pipeline_group.add_argument(
+        "--hpi_config",
+        type=ast.literal_eval,
+        help="High-performance inference configuration.",
+    )
+    pipeline_group.add_argument(
+        "--get_pipeline_config",
+        type=str,
+        default=None,
+        help="Retrieve the configuration for a specified pipeline.",
+    )
 
     ################# serving #################
-    parser.add_argument("--serve", action="store_true")
-    parser.add_argument("--host", type=str, default="0.0.0.0")
-    parser.add_argument("--port", type=int, default=8080)
+    serving_group.add_argument(
+        "--serve",
+        action="store_true",
+        help="Start the serving application to handle requests.",
+    )
+    serving_group.add_argument(
+        "--host",
+        type=str,
+        default="0.0.0.0",
+        help="Host address to serve on (default: 0.0.0.0).",
+    )
+    serving_group.add_argument(
+        "--port",
+        type=int,
+        default=8080,
+        help="Port number to serve on (default: 8080).",
+    )
+    # Serving also uses `--pipeline`, `--device`, `--use_hpip`, and `--hpi_config`
 
-    return parser
+    ################# paddle2onnx #################
+    paddle2onnx_group.add_argument(
+        "--paddle2onnx",
+        action="store_true",
+        help="Convert PaddlePaddle model to ONNX format.",
+    )
+    paddle2onnx_group.add_argument(
+        "--paddle_model_dir",
+        type=str,
+        help="Directory containing the PaddlePaddle model.",
+    )
+    paddle2onnx_group.add_argument(
+        "--onnx_model_dir",
+        type=str,
+        help="Output directory for the ONNX model.",
+    )
+    paddle2onnx_group.add_argument(
+        "--opset_version", type=int, default=7, help="Version of the ONNX opset to use."
+    )
+
+    # Parse known arguments to get the pipeline name
+    args, remaining_args = parser.parse_known_args()
+    pipeline = args.pipeline
+    pipeline_args = []
+
+    if not (args.install or args.serve or args.paddle2onnx) and pipeline is not None:
+        if os.path.isfile(pipeline):
+            pipeline_name = load_pipeline_config(pipeline)["pipeline_name"]
+        else:
+            pipeline_name = pipeline
+
+        if pipeline_name not in PIPELINE_ARGUMENTS:
+            support_pipelines = ", ".join(PIPELINE_ARGUMENTS.keys())
+            logging.error(
+                f"Unsupported pipeline: {pipeline_name}, CLI predict only supports these pipelines: {support_pipelines}\n"
+            )
+            sys.exit(1)
+
+        pipeline_args = PIPELINE_ARGUMENTS[pipeline_name]
+        if pipeline_args is None:
+            pipeline_args = []
+        pipeline_specific_group = parser.add_argument_group(
+            f"{pipeline_name.capitalize()} Pipeline Options"
+        )
+        for arg in pipeline_args:
+            pipeline_specific_group.add_argument(
+                arg["name"],
+                type=parse_str if arg["type"] is bool else arg["type"],
+                help=arg.get("help", f"Argument for {pipeline_name} pipeline."),
+            )
+
+    return parser, pipeline_args
 
 
 def install(args):
     """install paddlex"""
+
+    def _install_serving_deps():
+        reqs = get_serving_dep_specs()
+        # Should we sort the requirements?
+        install_packages(reqs)
+
+    def _install_paddle2onnx_deps():
+        install_packages([get_paddle2onnx_spec()])
+
+    def _install_hpi_deps(device_type):
+        SUPPORTED_DEVICE_TYPES = ["cpu", "gpu", "npu"]
+        if device_type not in SUPPORTED_DEVICE_TYPES:
+            logging.error(
+                "Failed to install the high-performance plugin.\n"
+                "Supported device types: %s. Your input device type: %s.\n",
+                SUPPORTED_DEVICE_TYPES,
+                device_type,
+            )
+            sys.exit(2)
+
+        if device_type == "cpu":
+            package = "ultra-infer-python"
+        elif device_type == "gpu":
+            if get_paddle_cuda_version()[0] != 11:
+                sys.exit(
+                    "You are not using PaddlePaddle compiled with CUDA 11. Currently, CUDA versions other than 11.x are not supported by the high-performance inference plugin."
+                )
+            package = "ultra-infer-gpu-python"
+        elif device_type == "npu":
+            package = "ultra-infer-npu-python"
+
+        with importlib.resources.path("paddlex", "hpip_links.html") as f:
+            install_packages([package], pip_install_opts=["--find-links", str(f)])
+
     # Enable debug info
     os.environ["PADDLE_PDX_DEBUG"] = "True"
     # Disable eager initialization
@@ -113,9 +267,38 @@ def install(args):
 
     if "serving" in plugins:
         plugins.remove("serving")
+        if plugins:
+            logging.error("`serving` cannot be used together with other plugins.")
+            sys.exit(2)
         _install_serving_deps()
         return
 
+    if "paddle2onnx" in plugins:
+        plugins.remove("paddle2onnx")
+        if plugins:
+            logging.error("`paddle2onnx` cannot be used together with other plugins.")
+            sys.exit(2)
+        _install_paddle2onnx_deps()
+        return
+
+    hpi_plugins = list(filter(lambda name: name.startswith("hpi-"), plugins))
+    if hpi_plugins:
+        for i in hpi_plugins:
+            plugins.remove(i)
+        if plugins:
+            logging.error("`hpi` cannot be used together with other plugins.")
+            sys.exit(2)
+        if len(hpi_plugins) > 1 or len(hpi_plugins[0].split("-")) != 2:
+            logging.error(
+                "Invalid HPI plugin installation format detected.\n"
+                "Correct format: paddlex --install hpi-<device_type>\n"
+                "Example: paddlex --install hpi-gpu"
+            )
+            sys.exit(2)
+        device_type = hpi_plugins[0].split("-")[1]
+        _install_hpi_deps(device_type=device_type)
+        return
+
     if plugins:
         repo_names = plugins
     elif len(plugins) == 0:
@@ -126,49 +309,131 @@ def install(args):
         platform=args.platform,
         update_repos=args.update_repos,
         use_local_repos=args.use_local_repos,
+        deps_to_replace=args.deps_to_replace,
     )
     return
 
 
-def _get_hpi_params(serial_number, update_license):
-    return {"serial_number": serial_number, "update_license": update_license}
-
-
 def pipeline_predict(
-    pipeline, input, device, save_path, use_hpip, serial_number, update_license
+    pipeline,
+    input,
+    device,
+    save_path,
+    use_hpip,
+    hpi_config,
+    **pipeline_args,
 ):
     """pipeline predict"""
-    hpi_params = _get_hpi_params(serial_number, update_license)
     pipeline = create_pipeline(
-        pipeline, device=device, use_hpip=use_hpip, hpi_params=hpi_params
+        pipeline, device=device, use_hpip=use_hpip, hpi_config=hpi_config
     )
-    result = pipeline(input)
+    result = pipeline.predict(input, **pipeline_args)
     for res in result:
-        res.print(json_format=False)
+        res.print()
         if save_path:
             res.save_all(save_path=save_path)
 
 
-def serve(pipeline, *, device, use_hpip, serial_number, update_license, host, port):
-    from .inference.pipelines.serving import create_pipeline_app, run_server
+def serve(pipeline, *, device, use_hpip, hpi_config, host, port):
+    from .inference.serving.basic_serving import create_pipeline_app, run_server
 
-    hpi_params = _get_hpi_params(serial_number, update_license)
     pipeline_config = load_pipeline_config(pipeline)
-    pipeline = create_pipeline_from_config(
-        pipeline_config, device=device, use_hpip=use_hpip, hpi_params=hpi_params
+    pipeline = create_pipeline(
+        config=pipeline_config, device=device, use_hpip=use_hpip, hpi_config=hpi_config
     )
     app = create_pipeline_app(pipeline, pipeline_config)
-    run_server(app, host=host, port=port, debug=False)
+    run_server(app, host=host, port=port)
+
+
+# TODO: Move to another module
+def paddle_to_onnx(paddle_model_dir, onnx_model_dir, *, opset_version):
+    require_paddle2onnx_plugin()
+
+    ONNX_MODEL_FILENAME = f"{MODEL_FILE_PREFIX}.onnx"
+    CONFIG_FILENAME = f"{MODEL_FILE_PREFIX}.yml"
+    ADDITIONAL_FILENAMES = ["scaler.pkl"]
+
+    def _check_input_dir(input_dir):
+        if input_dir is None:
+            sys.exit("Input directory must be specified")
+        if not input_dir.exists():
+            sys.exit(f"{input_dir} does not exist")
+        if not input_dir.is_dir():
+            sys.exit(f"{input_dir} is not a directory")
+        model_paths = get_model_paths(input_dir)
+        if "paddle" not in model_paths:
+            sys.exit("PaddlePaddle model does not exist")
+        config_path = input_dir / CONFIG_FILENAME
+        if not config_path.exists():
+            sys.exit(f"{config_path} does not exist")
+
+    def _check_paddle2onnx():
+        if shutil.which("paddle2onnx") is None:
+            sys.exit("Paddle2ONNX is not available. Please install the plugin first.")
+
+    def _run_paddle2onnx(input_dir, output_dir, opset_version):
+        model_paths = get_model_paths(input_dir)
+        logging.info("Paddle2ONNX conversion starting...")
+        # XXX: To circumvent Paddle2ONNX's bug
+        cmd = [
+            "paddle2onnx",
+            "--model_dir",
+            str(model_paths["paddle"][0].parent),
+            "--model_filename",
+            str(model_paths["paddle"][0].name),
+            "--params_filename",
+            str(model_paths["paddle"][1].name),
+            "--save_file",
+            str(output_dir / ONNX_MODEL_FILENAME),
+            "--opset_version",
+            str(opset_version),
+        ]
+        try:
+            subprocess.check_call(cmd)
+        except subprocess.CalledProcessError as e:
+            sys.exit(f"Paddle2ONNX conversion failed with exit code {e.returncode}")
+        logging.info("Paddle2ONNX conversion succeeded")
+
+    def _copy_config_file(input_dir, output_dir):
+        src_path = input_dir / CONFIG_FILENAME
+        dst_path = output_dir / CONFIG_FILENAME
+        shutil.copy(src_path, dst_path)
+        logging.info(f"Copied {src_path} to {dst_path}")
+
+    def _copy_additional_files(input_dir, output_dir):
+        for filename in ADDITIONAL_FILENAMES:
+            src_path = input_dir / filename
+            if not src_path.exists():
+                continue
+            dst_path = output_dir / filename
+            shutil.copy(src_path, dst_path)
+            logging.info(f"Copied {src_path} to {dst_path}")
+
+    paddle_model_dir = Path(paddle_model_dir)
+    if not onnx_model_dir:
+        onnx_model_dir = paddle_model_dir
+    onnx_model_dir = Path(onnx_model_dir)
+    logging.info(f"Input dir: {paddle_model_dir}")
+    logging.info(f"Output dir: {onnx_model_dir}")
+    _check_input_dir(paddle_model_dir)
+    _check_paddle2onnx()
+    _run_paddle2onnx(paddle_model_dir, onnx_model_dir, opset_version)
+    if not (onnx_model_dir.exists() and onnx_model_dir.samefile(paddle_model_dir)):
+        _copy_config_file(paddle_model_dir, onnx_model_dir)
+        _copy_additional_files(paddle_model_dir, onnx_model_dir)
+    logging.info("Done")
 
 
 # for CLI
 def main():
-    """API for commad line"""
-    args = args_cfg().parse_args()
+    """API for command line"""
+    parser, pipeline_args = args_cfg()
+    args = parser.parse_args()
+
     if len(sys.argv) == 1:
         logging.warning("No arguments provided. Displaying help information:")
-        args_cfg().print_help()
-        return
+        parser.print_help()
+        sys.exit(2)
 
     if args.install:
         install(args)
@@ -176,22 +441,35 @@ def main():
         serve(
             args.pipeline,
             device=args.device,
-            use_hpip=args.use_hpip,
-            serial_number=args.serial_number,
-            update_license=args.update_license,
+            use_hpip=args.use_hpip or None,
+            hpi_config=args.hpi_config,
             host=args.host,
             port=args.port,
         )
+    elif args.paddle2onnx:
+        paddle_to_onnx(
+            args.paddle_model_dir,
+            args.onnx_model_dir,
+            opset_version=args.opset_version,
+        )
     else:
         if args.get_pipeline_config is not None:
             interactive_get_pipeline(args.get_pipeline_config, args.save_path)
         else:
+            pipeline_args_dict = {}
+
+            for arg in pipeline_args:
+                arg_name = arg["name"].lstrip("-")
+                if hasattr(args, arg_name):
+                    pipeline_args_dict[arg_name] = getattr(args, arg_name)
+                else:
+                    logging.warning(f"Argument {arg_name} is missing in args")
             return pipeline_predict(
                 args.pipeline,
                 args.input,
                 args.device,
                 args.save_path,
-                use_hpip=args.use_hpip,
-                serial_number=args.serial_number,
-                update_license=args.update_license,
+                use_hpip=args.use_hpip or None,
+                hpi_config=args.hpi_config,
+                **pipeline_args_dict,
             )

paddlex/repo_apis/Paddle3D_api/__init__.py

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

paddlex/repo_apis/Paddle3D_api/bev_fusion/__init__.py

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

paddlex/repo_apis/Paddle3D_api/bev_fusion/config.py

@@ -0,0 +1,118 @@
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+from ....utils.misc import abspath
+from ..pp3d_config import PP3DConfig
+
+
+class BEVFusionConfig(PP3DConfig):
+    def update_dataset(
+        self, dataset_dir, datart_prefix=True, dataset_type=None, *, version=None
+    ):
+        dataset_dir = abspath(dataset_dir)
+        if dataset_type is None:
+            dataset_type = "NuscenesMMDataset"
+        if dataset_type == "NuscenesMMDataset":
+            ds_cfg = self._make_nuscenes_mm_dataset_config(
+                dataset_dir, datart_prefix, version=version
+            )
+        else:
+            raise ValueError(f"{dataset_type} is not supported.")
+        # Prune old config
+        keys_to_keep = ("transforms", "mode", "class_names", "modality")
+        if "train_dataset" in self:
+            for key in list(k for k in self.train_dataset if k not in keys_to_keep):
+                self.train_dataset.pop(key)
+        if "val_dataset" in self:
+            for key in list(k for k in self.val_dataset if k not in keys_to_keep):
+                self.val_dataset.pop(key)
+        self.update(ds_cfg)
+
+    def _make_nuscenes_mm_dataset_config(
+        self, dataset_root_path, datart_prefix, version
+    ):
+        if version is None:
+            # Default version
+            version = "trainval"
+        if version == "trainval":
+            train_mode = "train"
+            val_mode = "val"
+        elif version == "mini":
+            train_mode = "mini_train"
+            val_mode = "mini_val"
+        else:
+            raise ValueError("Unsupported version.")
+        return {
+            "train_dataset": {
+                "type": "NuscenesMMDataset",
+                "data_root": dataset_root_path,
+                "ann_file": f"{dataset_root_path}/nuscenes_infos_train.pkl",
+                "mode": train_mode,
+                "datart_prefix": datart_prefix,
+            },
+            "val_dataset": {
+                "type": "NuscenesMMDataset",
+                "data_root": dataset_root_path,
+                "ann_file": f"{dataset_root_path}/nuscenes_infos_val.pkl",
+                "mode": val_mode,
+                "datart_prefix": datart_prefix,
+            },
+        }
+
+    def _update_amp(self, amp):
+        # XXX: Currently, we hard-code the AMP settings according to
+        # https://github.com/PaddlePaddle/Paddle3D/blob/3cf884ecbc94330be0e2db780434bb60b9b4fe8c/configs/smoke/smoke_dla34_no_dcn_kitti_amp.yml#L6
+        amp_cfg = {
+            "amp_cfg": {
+                "use_amp": False,
+                "enable": False,
+                "level": amp,
+                "scaler": {"init_loss_scaling": 512.0},
+                "custom_black_list": ["matmul_v2", "elementwise_mul"],
+            }
+        }
+        self.update(amp_cfg)
+
+    def update_class_names(self, class_names):
+        if "train_dataset" in self and "transforms" in getattr(self, "train_dataset"):
+            self.train_dataset["class_names"] = class_names
+            # TODO: Provide another method to customize `SampleNameFilter` classes names
+            # TODO: Give an explicit warning for the implicit behavior
+            tf_cfg_list = self.train_dataset["transforms"]
+            for tf_cfg in tf_cfg_list:
+                if tf_cfg["type"] == "SampleNameFilter":
+                    tf_cfg["classes"] = class_names
+                    # We assume that there is at most one `SampleNameFilter` in `tf_cfg_list`
+                    break
+        if "val_dataset" in self:
+            self.val_dataset["class_names"] = class_names
+
+    def update_pretrained_model(self, load_cam_from: str, load_lidar_from: str):
+        """update model pretrained weight
+
+        Args:
+            load_cam_from (str): the path to cam weight file of model.
+            load_lidar_from (str): the path to lidar weight file of model.
+        """
+        self.model["load_cam_from"] = load_cam_from
+        self.model["load_lidar_from"] = load_lidar_from
+
+    def update_weights(self, weight_path: str):
+        """update model weight
+
+        Args:
+            weight_path (str): the path to weight file of model.
+        """
+        self["weights"] = weight_path