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

paddlex/inference/utils/pp_option.py

@@ -13,8 +13,14 @@
 # limitations under the License.
 
 import os
-
-from ...utils.device import parse_device, set_env_for_device, get_default_device
+from typing import Dict, List
+
+from ...utils.device import (
+    parse_device,
+    set_env_for_device,
+    get_default_device,
+    check_supported_device,
+)
 from ...utils import logging
 from .new_ir_blacklist import NEWIR_BLOCKLIST
 
@@ -31,7 +37,7 @@ class PaddlePredictorOption(object):
         "mkldnn",
         "mkldnn_bf16",
     )
-    SUPPORT_DEVICE = ("gpu", "cpu", "npu", "xpu", "mlu", "dcu")
+    SUPPORT_DEVICE = ("gpu", "cpu", "npu", "xpu", "mlu", "dcu", "gcu")
 
     def __init__(self, model_name=None, **kwargs):
         super().__init__()
@@ -75,6 +81,7 @@ class PaddlePredictorOption(object):
             "delete_pass": [],
             "enable_new_ir": True if self.model_name not in NEWIR_BLOCKLIST else False,
             "batch_size": 1,  # only for trt
+            "trt_dynamic_shapes": {},  # only for trt
         }
 
     def _update(self, k, v):
@@ -105,7 +112,9 @@ class PaddlePredictorOption(object):
 
     @property
     def device(self):
-        return self._cfg["device"]
+        device = self._cfg["device"]
+        check_supported_device(device, self.model_name)
+        return device
 
     @device.setter
     def device(self, device: str):
@@ -149,6 +158,17 @@ class PaddlePredictorOption(object):
         """set shape info filename"""
         self._update("shape_info_filename", shape_info_filename)
 
+    @property
+    def trt_dynamic_shapes(self):
+        return self._cfg["trt_dynamic_shapes"]
+
+    @trt_dynamic_shapes.setter
+    def trt_dynamic_shapes(self, trt_dynamic_shapes: Dict[str, List[List[int]]]):
+        assert isinstance(trt_dynamic_shapes, dict)
+        for input_k in trt_dynamic_shapes:
+            assert isinstance(trt_dynamic_shapes[input_k], list)
+        self._update("trt_dynamic_shapes", trt_dynamic_shapes)
+
     @property
     def trt_calib_mode(self):
         return self._cfg["trt_calib_mode"]

paddlex/model.py

@@ -25,8 +25,10 @@ from .modules import (
 
 
 # TODO(gaotingquan): support _ModelBasedConfig
-def create_model(model=None, *args, **kwargs):
-    return _ModelBasedInference(model, *args, **kwargs)
+def create_model(model_name, model_dir=None, *args, **kwargs):
+    return _ModelBasedInference(
+        model_name=model_name, model_dir=model_dir, *args, **kwargs
+    )
 
 
 class _BaseModel:
@@ -62,6 +64,13 @@ class _ModelBasedInference(_BaseModel):
     def set_predictor(self, **kwargs):
         self._predictor.set_predictor(**kwargs)
 
+    def __getattr__(self, name):
+        if hasattr(self._predictor, name):
+            return getattr(self._predictor, name)
+        raise AttributeError(
+            f"'{self.__class__.__name__}' object has no attribute '{name}'"
+        )
+
 
 class _ModelBasedConfig(_BaseModel):
     def __init__(self, config=None, *args, **kwargs):
@@ -73,15 +82,13 @@ class _ModelBasedConfig(_BaseModel):
         predict_kwargs = deepcopy(self._config.Predict)
 
         model_dir = predict_kwargs.pop("model_dir", None)
-        # if model_dir is None, using official
-        model = self._model_name if model_dir is None else model_dir
 
         device = self._config.Global.get("device")
         kernel_option = predict_kwargs.pop("kernel_option", {})
         kernel_option.update({"device": device})
 
         pp_option = PaddlePredictorOption(self._model_name, **kernel_option)
-        predictor = create_predictor(model, pp_option=pp_option)
+        predictor = create_predictor(self._model_name, model_dir, pp_option=pp_option)
         assert "input" in predict_kwargs
         return predict_kwargs, predictor
 

paddlex/modules/3d_bev_detection/__init__.py

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

paddlex/modules/3d_bev_detection/dataset_checker/__init__.py

@@ -0,0 +1,95 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from pathlib import Path
+import pickle
+
+from ...base import BaseDatasetChecker
+from .dataset_src import check, deep_analyse
+from ..model_list import MODELS
+
+
+class BEVFusionDatasetChecker(BaseDatasetChecker):
+    entities = MODELS
+
+    def check_dataset(self, dataset_dir: str) -> dict:
+        """check if the dataset meets the specifications and get dataset summary
+
+        Args:
+            dataset_dir (str): the root directory of dataset.
+            sample_num (int): the number to be sampled.
+        Returns:
+            dict: dataset summary.
+        """
+        return check(dataset_dir)
+
+    def analyse(self, dataset_dir: str) -> dict:
+        """deep analyse dataset
+
+        Args:
+            dataset_dir (str): the root directory of dataset.
+
+        Returns:
+            dict: the deep analysis results.
+        """
+        return deep_analyse(dataset_dir, self.output)
+
+    def get_data(self, ann_file, max_sample_num):
+        infos = self.data_infos(ann_file, max_sample_num)
+        meta = []
+        for info in infos:
+            image_paths = []
+            cam_orders = [
+                "CAM_FRONT_LEFT",
+                "CAM_FRONT",
+                "CAM_FRONT_RIGHT",
+                "CAM_BACK_RIGHT",
+                "CAM_BACK",
+                "CAM_BACK_LEFT",
+            ]
+            for cam_type in cam_orders:
+                cam_info = info["cams"][cam_type]
+                cam_data_path = cam_info["data_path"]
+                image_paths.append(cam_data_path)
+
+            meta.append(
+                {
+                    "sample_idx": info["token"],
+                    "lidar_path": info["lidar_path"],
+                    "image_paths": image_paths,
+                }
+            )
+        return meta
+
+    def data_infos(self, ann_file, max_sample_num):
+        data = pickle.load(open(ann_file, "rb"))
+        data_infos = list(sorted(data["infos"], key=lambda e: e["timestamp"]))
+        data_infos = data_infos[:max_sample_num]
+        return data_infos
+
+    def get_show_type(self) -> str:
+        """get the show type of dataset
+
+        Returns:
+            str: show type
+        """
+        return "txt"
+
+    def get_dataset_type(self) -> str:
+        """return the dataset type
+
+        Returns:
+            str: dataset type
+        """
+        return "NuscenesMMDataset"

paddlex/modules/3d_bev_detection/dataset_checker/dataset_src/__init__.py

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

paddlex/modules/3d_bev_detection/dataset_checker/dataset_src/analyse_dataset.py

@@ -0,0 +1,106 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import os
+import json
+import platform
+import pickle
+
+from collections import defaultdict
+
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib import font_manager
+from matplotlib.backends.backend_agg import FigureCanvasAgg
+
+from paddlex.utils.fonts import PINGFANG_FONT_FILE_PATH
+
+
+def deep_analyse(dataset_dir, output):
+    """class analysis for dataset"""
+    tags = ["train", "val"]
+    all_instances = 0
+    class_name_train = defaultdict(int)
+    class_name_val = defaultdict(int)
+    for tag in tags:
+        anno_file = os.path.join(dataset_dir, f"nuscenes_infos_{tag}.pkl")
+        with open(anno_file, "rb") as f:
+            datas = pickle.load(f)
+        data_infos = datas["infos"]
+        for item in data_infos:
+            gts = item["gt_names"]
+            for gt_name in gts:
+                if tag == "train":
+                    class_name_train[gt_name] = (
+                        0
+                        if gt_name not in class_name_train
+                        else class_name_train[gt_name] + 1
+                    )
+                elif tag == "val":
+                    class_name_val[gt_name] = (
+                        0
+                        if gt_name not in class_name_val
+                        else class_name_val[gt_name] + 1
+                    )
+
+    classes = set()
+    for key in class_name_train:
+        classes.add(key)
+    for key in class_name_val:
+        classes.add(key)
+
+    # set cnt to 0 if class not in cnt dict
+    for key in classes:
+        if key not in class_name_train:
+            class_name_train[key] = 0
+        if key not in class_name_val:
+            class_name_val[key] = 0
+
+    cnts_train = [cat_ids for cat_name, cat_ids in class_name_train.items()]
+    cnts_val = [cat_ids for cat_name, cat_ids in class_name_val.items()]
+
+    # sort class name
+    classes = [cat_name for cat_name, cat_ids in class_name_train.items()]
+    sorted_id = sorted(
+        range(len(cnts_train)), key=lambda k: cnts_train[k], reverse=True
+    )
+    cnts_train_sorted = [cnts_train[index] for index in sorted_id]
+    cnts_val_sorted = [cnts_val[index] for index in sorted_id]
+    classes_sorted = [classes[index] for index in sorted_id]
+
+    x = np.arange(len(classes))
+    width = 0.5
+
+    # bar
+    os_system = platform.system().lower()
+    if os_system == "windows":
+        plt.rcParams["font.sans-serif"] = "FangSong"
+    else:
+        font = font_manager.FontProperties(fname=PINGFANG_FONT_FILE_PATH)
+    fig, ax = plt.subplots(figsize=(max(8, int(len(classes) / 5)), 5), dpi=120)
+    ax.bar(x, cnts_train_sorted, width=0.5, label="train")
+    ax.bar(x + width, cnts_val_sorted, width=0.5, label="val")
+    plt.xticks(
+        x + width / 2,
+        classes_sorted,
+        rotation=90,
+        fontproperties=None if os_system == "windows" else font,
+    )
+    ax.set_ylabel("Counts")
+    plt.legend()
+    fig.tight_layout()
+    fig_path = os.path.join(output, "histogram.png")
+    fig.savefig(fig_path)
+    return {"histogram": os.path.join("check_dataset", "histogram.png")}

paddlex/modules/3d_bev_detection/dataset_checker/dataset_src/check_dataset.py

@@ -0,0 +1,102 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import os.path as osp
+import pickle
+
+from .....utils.errors import DatasetFileNotFoundError
+from .....utils.misc import abspath
+
+
+def check(dataset_dir):
+    dataset_dir = abspath(dataset_dir)
+    max_sample_num = 5
+
+    if not osp.exists(dataset_dir) or not osp.isdir(dataset_dir):
+        raise DatasetFileNotFoundError(file_path=dataset_dir)
+
+    anno_file = osp.join(dataset_dir, "nuscenes_infos_train.pkl")
+    if not osp.exists(anno_file):
+        raise DatasetFileNotFoundError(file_path=anno_file)
+    train_mate, train_classes = get_data(anno_file, max_sample_num)
+
+    anno_file = osp.join(dataset_dir, "nuscenes_infos_val.pkl")
+    if not osp.exists(anno_file):
+        raise DatasetFileNotFoundError(file_path=anno_file)
+    val_mate, val_classes = get_data(anno_file, max_sample_num)
+    train_sample_paths = []
+    val_sample_paths = []
+
+    for item in train_mate:
+        train_sample_paths.append(item["lidar_path"])
+
+    for item in val_mate:
+        val_sample_paths.append(item["lidar_path"])
+
+    all_classes = set()
+    for tc in train_classes:
+        all_classes.add(tc)
+    for vc in val_classes:
+        all_classes.add(vc)
+    num_classes = len(all_classes)
+    meta = {
+        "num_classes": num_classes,
+        "train_meta": train_mate,
+        "val_meta": val_mate,
+        "train_sample_paths": train_sample_paths,
+        "val_sample_paths": val_sample_paths,
+    }
+    return meta
+
+
+def get_data(ann_file, max_sample_num):
+    infos = data_infos(ann_file, max_sample_num)
+    meta = []
+    gt_class = set()
+    for info in infos:
+        image_paths = []
+        cam_orders = [
+            "CAM_FRONT_LEFT",
+            "CAM_FRONT",
+            "CAM_FRONT_RIGHT",
+            "CAM_BACK_RIGHT",
+            "CAM_BACK",
+            "CAM_BACK_LEFT",
+        ]
+        for cam_type in cam_orders:
+            cam_info = info["cams"][cam_type]
+            cam_data_path = cam_info["data_path"]
+            image_paths.append(cam_data_path)
+
+        meta.append(
+            {
+                "sample_idx": info["token"],
+                "lidar_path": info["lidar_path"],
+                "image_paths": image_paths,
+            }
+        )
+        class_names = info["gt_names"]
+
+        for cls_name in class_names:
+            gt_class.add(cls_name)
+
+    return meta, gt_class
+
+
+def data_infos(ann_file, max_sample_num):
+    data = pickle.load(open(ann_file, "rb"))
+    data_infos = list(sorted(data["infos"], key=lambda e: e["timestamp"]))
+    data_infos = data_infos[:max_sample_num]
+    return data_infos

paddlex/modules/3d_bev_detection/evaluator.py

@@ -0,0 +1,46 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+from ..base import BaseEvaluator
+from .model_list import MODELS
+
+
+class BEVFusionEvaluator(BaseEvaluator):
+    """Object Detection Model Evaluator"""
+
+    entities = MODELS
+
+    def update_config(self):
+        """update evalution config"""
+        if self.eval_config.batch_size is not None:
+            self.pdx_config.update_batch_size(self.eval_config.batch_size)
+        self.pdx_config.update_dataset(
+            self.global_config.dataset_dir,
+            self.global_config.datart_prefix,
+            "NuscenesMMDataset",
+            version=self.global_config.version,
+        )
+        self.pdx_config.update_weights(self.eval_config.weight_path)
+
+    def get_eval_kwargs(self) -> dict:
+        """get key-value arguments of model evalution function
+
+        Returns:
+            dict: the arguments of evaluation function.
+        """
+        return {
+            "weight_path": self.eval_config.weight_path,
+            "device": self.get_device(using_device_number=1),
+        }

paddlex/modules/3d_bev_detection/exportor.py

@@ -0,0 +1,22 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from ..base import BaseExportor
+from .model_list import MODELS
+
+
+class BEVFusionExportor(BaseExportor):
+    """3D BEV Detection Model Exportor"""
+
+    entities = MODELS

paddlex/modules/3d_bev_detection/model_list.py

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

paddlex/modules/3d_bev_detection/trainer.py

@@ -0,0 +1,70 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+from pathlib import Path
+
+from ..base import BaseTrainer
+from ...utils.config import AttrDict
+from ...utils import logging
+from .model_list import MODELS
+
+
+class BEVFusionTrainer(BaseTrainer):
+    """3D BEV Detection Model Trainer"""
+
+    entities = MODELS
+
+    def _update_dataset(self):
+        """update dataset settings"""
+        self.pdx_config.update_dataset(
+            self.global_config.dataset_dir,
+            self.global_config.get("datart_prefix", True),
+            "NuscenesMMDataset",
+            version=self.global_config.get("version", "mini"),
+        )
+
+    def _update_pretrained_model(self):
+        self.pdx_config.update_pretrained_model(
+            self.global_config.load_cam_from, self.global_config.load_lidar_from
+        )
+
+    def update_config(self):
+        """update training config"""
+        self._update_dataset()
+        self._update_pretrained_model()
+
+        if self.train_config.batch_size is not None:
+            self.pdx_config.update_batch_size(self.train_config.batch_size)
+        if self.train_config.learning_rate is not None:
+            self.pdx_config.update_learning_rate(self.train_config.learning_rate)
+        if self.train_config.epochs_iters is not None:
+            self.pdx_config.update_epochs(self.train_config.epochs_iters)
+            epochs_iters = self.train_config.epochs_iters
+        else:
+            epochs_iters = self.pdx_config.get_epochs_iters()
+        if self.global_config.output is not None:
+            self.pdx_config.update_save_dir(self.global_config.output)
+
+    def get_train_kwargs(self) -> dict:
+        """get key-value arguments of model training function
+
+        Returns:
+            dict: the arguments of training function.
+        """
+        train_args = {"device": self.get_device()}
+        train_args["dy2st"] = self.train_config.get("dy2st", False)
+        if self.global_config.output is not None:
+            train_args["save_dir"] = self.global_config.output
+        return train_args

paddlex/modules/__init__.py

@@ -11,7 +11,7 @@
 # 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 importlib import import_module
 
 from .base import (
     build_dataset_checker,
@@ -103,3 +103,36 @@ from .face_recognition import (
 )
 
 from .ts_forecast import TSFCDatasetChecker, TSFCTrainer, TSFCEvaluator
+
+module_3d_bev_detection = import_module(".3d_bev_detection", "paddlex.modules")
+BEVFusionDatasetChecker = getattr(module_3d_bev_detection, "BEVFusionDatasetChecker")
+BEVFusionTrainer = getattr(module_3d_bev_detection, "BEVFusionTrainer")
+BEVFusionEvaluator = getattr(module_3d_bev_detection, "BEVFusionEvaluator")
+BEVFusionExportor = getattr(module_3d_bev_detection, "BEVFusionExportor")
+
+from .keypoint_detection import (
+    KeypointDatasetChecker,
+    KeypointTrainer,
+    KeypointEvaluator,
+    KeypointExportor,
+)
+from .video_classification import (
+    VideoClsDatasetChecker,
+    VideoClsTrainer,
+    VideoClsEvaluator,
+    VideoClsExportor,
+)
+
+from .video_detection import (
+    VideoDetDatasetChecker,
+    VideoDetTrainer,
+    VideoDetEvaluator,
+    VideoDetExportor,
+)
+
+from .multilingual_speech_recognition import (
+    WhisperDatasetChecker,
+    WhisperTrainer,
+    WhisperEvaluator,
+    WhisperExportor,
+)

paddlex/modules/base/build_model.py

@@ -22,7 +22,7 @@ def build_model(model_name: str, config_path: str = None) -> tuple:
 
     Args:
         model_name (str): model name
-        device (str): device, such as gpu, cpu, npu, xpu, mlu
+        device (str): device, such as gpu, cpu, npu, xpu, mlu, gcu
         config_path (str, optional): path to the PaddleX config yaml file.
             Defaults to None, i.e. using the default config file.
 

paddlex/modules/base/dataset_checker/dataset_checker.py

@@ -32,6 +32,11 @@ def build_dataset_checker(config: AttrDict) -> "BaseDatasetChecker":
         BaseDatasetChecker: the dataset checker, which is subclass of BaseDatasetChecker.
     """
     model_name = config.Global.model
+    try:
+        import feature_line_modules
+    except ModuleNotFoundError:
+        pass
+
     return BaseDatasetChecker.get(model_name)(config)
 
 
@@ -77,7 +82,7 @@ class BaseDatasetChecker(ABC, metaclass=AutoRegisterABCMetaClass):
         check_result = build_res_dict(True)
         check_result["attributes"] = attrs
         check_result["analysis"] = analysis
-        check_result["dataset_path"] = self.global_config.dataset_dir
+        check_result["dataset_path"] = os.path.basename(dataset_dir)
         check_result["show_type"] = self.get_show_type()
         check_result["dataset_type"] = self.get_dataset_type()
         info("Check dataset passed !")