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

paddlex/inference/components/paddle_predictor/predictor.py

@@ -1,332 +0,0 @@
-# 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
-from abc import abstractmethod
-import lazy_paddle as paddle
-import numpy as np
-
-from ....utils.flags import FLAGS_json_format_model
-from ....utils import logging
-from ...utils.pp_option import PaddlePredictorOption
-from ..base import BaseComponent
-
-
-class Copy2GPU(BaseComponent):
-
-    def __init__(self, input_handlers):
-        super().__init__()
-        self.input_handlers = input_handlers
-
-    def apply(self, x):
-        for idx in range(len(x)):
-            self.input_handlers[idx].reshape(x[idx].shape)
-            self.input_handlers[idx].copy_from_cpu(x[idx])
-
-
-class Copy2CPU(BaseComponent):
-
-    def __init__(self, output_handlers):
-        super().__init__()
-        self.output_handlers = output_handlers
-
-    def apply(self):
-        output = []
-        for out_tensor in self.output_handlers:
-            batch = out_tensor.copy_to_cpu()
-            output.append(batch)
-        return output
-
-
-class Infer(BaseComponent):
-
-    def __init__(self, predictor):
-        super().__init__()
-        self.predictor = predictor
-
-    def apply(self):
-        self.predictor.run()
-
-
-class BasePaddlePredictor(BaseComponent):
-    """Predictor based on Paddle Inference"""
-
-    OUTPUT_KEYS = "pred"
-    DEAULT_OUTPUTS = {"pred": "pred"}
-    ENABLE_BATCH = True
-
-    def __init__(self, model_dir, model_prefix, option):
-        super().__init__()
-        self.model_dir = model_dir
-        self.model_prefix = model_prefix
-        self._update_option(option)
-
-    def _update_option(self, option):
-        if option:
-            if self.option and option == self.option:
-                return
-            self._option = option
-            self._reset()
-
-    @property
-    def option(self):
-        return self._option if hasattr(self, "_option") else None
-
-    @option.setter
-    def option(self, option):
-        self._update_option(option)
-
-    def _reset(self):
-        if not self.option:
-            self.option = PaddlePredictorOption()
-        logging.debug(f"Env: {self.option}")
-        (
-            predictor,
-            input_handlers,
-            output_handlers,
-        ) = self._create()
-        self.copy2gpu = Copy2GPU(input_handlers)
-        self.copy2cpu = Copy2CPU(output_handlers)
-        self.infer = Infer(predictor)
-        self.option.changed = False
-
-    def _create(self):
-        """_create"""
-        from lazy_paddle.inference import Config, create_predictor
-
-        model_postfix = ".json" if FLAGS_json_format_model else ".pdmodel"
-        model_file = (self.model_dir / f"{self.model_prefix}{model_postfix}").as_posix()
-        params_file = (self.model_dir / f"{self.model_prefix}.pdiparams").as_posix()
-        config = Config(model_file, params_file)
-
-        config.enable_memory_optim()
-        if self.option.device in ("gpu", "dcu"):
-            if self.option.device == "gpu":
-                config.exp_disable_mixed_precision_ops({"feed", "fetch"})
-            config.enable_use_gpu(100, self.option.device_id)
-            if self.option.device == "gpu":
-                # NOTE: The pptrt settings are not aligned with those of FD.
-                precision_map = {
-                    "trt_int8": Config.Precision.Int8,
-                    "trt_fp32": Config.Precision.Float32,
-                    "trt_fp16": Config.Precision.Half,
-                }
-                if self.option.run_mode in precision_map.keys():
-                    config.enable_tensorrt_engine(
-                        workspace_size=(1 << 25) * self.option.batch_size,
-                        max_batch_size=self.option.batch_size,
-                        min_subgraph_size=self.option.min_subgraph_size,
-                        precision_mode=precision_map[self.option.run_mode],
-                        use_static=self.option.trt_use_static,
-                        use_calib_mode=self.option.trt_calib_mode,
-                    )
-
-                    if self.option.shape_info_filename is not None:
-                        if not os.path.exists(self.option.shape_info_filename):
-                            config.collect_shape_range_info(
-                                self.option.shape_info_filename
-                            )
-                            logging.info(
-                                f"Dynamic shape info is collected into: {self.option.shape_info_filename}"
-                            )
-                        else:
-                            logging.info(
-                                f"A dynamic shape info file ( {self.option.shape_info_filename} ) already exists. \
-        No need to generate again."
-                            )
-                        config.enable_tuned_tensorrt_dynamic_shape(
-                            self.option.shape_info_filename, True
-                        )
-        elif self.option.device == "npu":
-            config.enable_custom_device("npu")
-        elif self.option.device == "xpu":
-            pass
-        elif self.option.device == "mlu":
-            config.enable_custom_device("mlu")
-        else:
-            assert self.option.device == "cpu"
-            config.disable_gpu()
-            if "mkldnn" in self.option.run_mode:
-                try:
-                    config.enable_mkldnn()
-                    if "bf16" in self.option.run_mode:
-                        config.enable_mkldnn_bfloat16()
-                except Exception as e:
-                    logging.warning(
-                        "MKL-DNN is not available. We will disable MKL-DNN."
-                    )
-                config.set_mkldnn_cache_capacity(-1)
-            else:
-                if hasattr(config, "disable_mkldnn"):
-                    config.disable_mkldnn()
-
-        # Disable paddle inference logging
-        config.disable_glog_info()
-
-        config.set_cpu_math_library_num_threads(self.option.cpu_threads)
-
-        if self.option.device in ("cpu", "gpu"):
-            if not (
-                self.option.device == "gpu" and self.option.run_mode.startswith("trt")
-            ):
-                if hasattr(config, "enable_new_ir"):
-                    config.enable_new_ir(self.option.enable_new_ir)
-                if hasattr(config, "enable_new_executor"):
-                    config.enable_new_executor()
-                config.set_optimization_level(3)
-
-        for del_p in self.option.delete_pass:
-            config.delete_pass(del_p)
-
-        if self.option.device in ("gpu", "dcu"):
-            if paddle.is_compiled_with_rocm():
-                # Delete unsupported passes in dcu
-                config.delete_pass("conv2d_add_act_fuse_pass")
-                config.delete_pass("conv2d_add_fuse_pass")
-
-        predictor = create_predictor(config)
-
-        # Get input and output handlers
-        input_names = predictor.get_input_names()
-        input_names.sort()
-        input_handlers = []
-        output_handlers = []
-        for input_name in input_names:
-            input_handler = predictor.get_input_handle(input_name)
-            input_handlers.append(input_handler)
-        output_names = predictor.get_output_names()
-        for output_name in output_names:
-            output_handler = predictor.get_output_handle(output_name)
-            output_handlers.append(output_handler)
-        return predictor, input_handlers, output_handlers
-
-    def apply(self, **kwargs):
-        if self.option.changed:
-            self._reset()
-        batches = self.to_batch(**kwargs)
-        self.copy2gpu.apply(batches)
-        self.infer.apply()
-        pred = self.copy2cpu.apply()
-        return self.format_output(pred)
-
-    @property
-    def sub_cmps(self):
-        return {
-            "Copy2GPU": self.copy2gpu,
-            "Infer": self.infer,
-            "Copy2CPU": self.copy2cpu,
-        }
-
-    @abstractmethod
-    def to_batch(self):
-        raise NotImplementedError
-
-    @abstractmethod
-    def format_output(self, pred):
-        return [{"pred": res} for res in zip(*pred)]
-
-
-class ImagePredictor(BasePaddlePredictor):
-    INPUT_KEYS = "img"
-    OUTPUT_KEYS = "pred"
-    DEAULT_INPUTS = {"img": "img"}
-    DEAULT_OUTPUTS = {"pred": "pred"}
-
-    def to_batch(self, img):
-        return [np.stack(img, axis=0).astype(dtype=np.float32, copy=False)]
-
-    def format_output(self, pred):
-        return [{"pred": res} for res in zip(*pred)]
-
-
-class ImageDetPredictor(BasePaddlePredictor):
-
-    INPUT_KEYS = [
-        ["img", "scale_factors"],
-        ["img", "scale_factors", "img_size"],
-        ["img", "img_size"],
-    ]
-    OUTPUT_KEYS = [["boxes"], ["boxes", "masks"]]
-    DEAULT_INPUTS = {"img": "img", "scale_factors": "scale_factors"}
-    DEAULT_OUTPUTS = None
-
-    def to_batch(self, img, scale_factors=[[1.0, 1.0]], img_size=None):
-        scale_factors = [scale_factor[::-1] for scale_factor in scale_factors]
-        if img_size is None:
-            return [
-                np.stack(img, axis=0).astype(dtype=np.float32, copy=False),
-                np.stack(scale_factors, axis=0).astype(dtype=np.float32, copy=False),
-            ]
-        else:
-            img_size = [img_size[::-1] for img_size in img_size]
-            return [
-                np.stack(img_size, axis=0).astype(dtype=np.float32, copy=False),
-                np.stack(img, axis=0).astype(dtype=np.float32, copy=False),
-                np.stack(scale_factors, axis=0).astype(dtype=np.float32, copy=False),
-            ]
-
-    def format_output(self, pred):
-        box_idx_start = 0
-        pred_box = []
-
-        if len(pred) == 4:
-            # Adapt to SOLOv2
-            pred_class_id = []
-            pred_mask = []
-            pred_class_id.append([pred[1], pred[2]])
-            pred_mask.append(pred[3])
-            return [
-                {
-                    "class_id": np.array(pred_class_id[i]),
-                    "masks": np.array(pred_mask[i]),
-                }
-                for i in range(len(pred_class_id))
-            ]
-
-        if len(pred) == 3:
-            # Adapt to Instance Segmentation
-            pred_mask = []
-        for idx in range(len(pred[1])):
-            np_boxes_num = pred[1][idx]
-            box_idx_end = box_idx_start + np_boxes_num
-            np_boxes = pred[0][box_idx_start:box_idx_end]
-            pred_box.append(np_boxes)
-            if len(pred) == 3:
-                np_masks = pred[2][box_idx_start:box_idx_end]
-                pred_mask.append(np_masks)
-            box_idx_start = box_idx_end
-
-        if len(pred) == 3:
-            return [
-                {"boxes": np.array(pred_box[i]), "masks": np.array(pred_mask[i])}
-                for i in range(len(pred_box))
-            ]
-        else:
-            return [{"boxes": np.array(res)} for res in pred_box]
-
-
-class TSPPPredictor(BasePaddlePredictor):
-
-    INPUT_KEYS = "ts"
-    OUTPUT_KEYS = "pred"
-    DEAULT_INPUTS = {"ts": "ts"}
-    DEAULT_OUTPUTS = {"pred": "pred"}
-
-    def to_batch(self, ts):
-        n = len(ts[0])
-        x = [np.stack([lst[i] for lst in ts], axis=0) for i in range(n)]
-        return x
-
-    def format_output(self, pred):
-        return [{"pred": res} for res in zip(*pred)]

paddlex/inference/components/retrieval/__init__.py

@@ -1,15 +0,0 @@
-# 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 .faiss import FaissIndexer, FaissBuilder

paddlex/inference/components/retrieval/faiss.py

@@ -1,359 +0,0 @@
-# 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 pickle
-from pathlib import Path
-import faiss
-import numpy as np
-
-from ....utils import logging
-from ...utils.io import YAMLWriter, YAMLReader
-from ..base import BaseComponent
-
-
-class IndexData:
-    VECTOR_FN = "vector"
-    VECTOR_SUFFIX = ".index"
-    IDMAP_FN = "id_map"
-    IDMAP_SUFFIX = ".yaml"
-
-    def __init__(self, index, index_info):
-        self._index = index
-        self._index_info = index_info
-        self._id_map = index_info["id_map"]
-        self._metric_type = index_info["metric_type"]
-        self._index_type = index_info["index_type"]
-
-    @property
-    def index(self):
-        return self._index
-
-    @property
-    def index_bytes(self):
-        return faiss.serialize_index(self._index)
-
-    @property
-    def id_map(self):
-        return self._id_map
-
-    @property
-    def metric_type(self):
-        return self._metric_type
-
-    @property
-    def index_type(self):
-        return self._index_type
-
-    @property
-    def index_info(self):
-        return {
-            "index_type": self.index_type,
-            "metric_type": self.metric_type,
-            "id_map": self._convert_int(self.id_map),
-        }
-
-    def _convert_int(self, id_map):
-        return {int(k): str(v) for k, v in id_map.items()}
-
-    @staticmethod
-    def _convert_int64(id_map):
-        return {np.int64(k): str(v) for k, v in id_map.items()}
-
-    def save(self, save_dir):
-        save_dir = Path(save_dir)
-        save_dir.mkdir(parents=True, exist_ok=True)
-        vector_path = (save_dir / f"{self.VECTOR_FN}{self.VECTOR_SUFFIX}").as_posix()
-        index_info_path = (save_dir / f"{self.IDMAP_FN}{self.IDMAP_SUFFIX}").as_posix()
-
-        if self.metric_type in FaissBuilder.BINARY_METRIC_TYPE:
-            faiss.write_index_binary(self.index, vector_path)
-        else:
-            faiss.write_index(self.index, vector_path)
-
-        yaml_writer = YAMLWriter()
-        yaml_writer.write(
-            index_info_path,
-            self.index_info,
-            default_flow_style=False,
-            allow_unicode=True,
-        )
-
-    @classmethod
-    def load(cls, index):
-        if isinstance(index, str):
-            index_root = Path(index)
-            vector_path = index_root / f"{cls.VECTOR_FN}{cls.VECTOR_SUFFIX}"
-            index_info_path = index_root / f"{cls.IDMAP_FN}{cls.IDMAP_SUFFIX}"
-
-            assert (
-                vector_path.exists()
-            ), f"Not found the {cls.VECTOR_FN}{cls.VECTOR_SUFFIX} file in {index}!"
-            assert (
-                index_info_path.exists()
-            ), f"Not found the {cls.IDMAP_FN}{cls.IDMAP_SUFFIX} file in {index}!"
-
-            yaml_reader = YAMLReader()
-            index_info = yaml_reader.read(index_info_path)
-            assert (
-                "id_map" in index_info
-                and "metric_type" in index_info
-                and "index_type" in index_info
-            ), f"The index_info file({index_info_path}) may have been damaged, `id_map` or `metric_type` or `index_type` not found in `index_info`."
-            id_map = IndexData._convert_int64(index_info["id_map"])
-
-            if index_info["metric_type"] in FaissBuilder.BINARY_METRIC_TYPE:
-                index = faiss.read_index_binary(vector_path.as_posix())
-            else:
-                index = faiss.read_index(vector_path.as_posix())
-            assert index.ntotal == len(
-                id_map
-            ), "data number in index is not equal in in id_map"
-
-            return index, id_map, index_info["metric_type"], index_info["index_type"]
-        else:
-            assert isinstance(index, IndexData)
-            return index.index, index.id_map, index.metric_type, index.index_type
-
-
-class FaissIndexer(BaseComponent):
-
-    INPUT_KEYS = "feature"
-    OUTPUT_KEYS = ["label", "score"]
-    DEAULT_INPUTS = {"feature": "feature"}
-    DEAULT_OUTPUTS = {"label": "label", "score": "score"}
-
-    ENABLE_BATCH = True
-
-    def __init__(
-        self,
-        index,
-        return_k=1,
-        score_thres=None,
-        hamming_radius=None,
-    ):
-        super().__init__()
-        self._indexer, self.id_map, self.metric_type, index_type = IndexData.load(index)
-        self.return_k = return_k
-        if self.metric_type in FaissBuilder.BINARY_METRIC_TYPE:
-            self.hamming_radius = hamming_radius
-        else:
-            self.score_thres = score_thres
-
-    def apply(self, feature):
-        """apply"""
-        scores_list, ids_list = self._indexer.search(np.array(feature), self.return_k)
-        preds = []
-        for scores, ids in zip(scores_list, ids_list):
-            labels = []
-            for id in ids:
-                if id > 0:
-                    labels.append(self.id_map[id])
-            preds.append({"score": scores, "label": labels})
-
-        if self.metric_type in FaissBuilder.BINARY_METRIC_TYPE:
-            idxs = np.where(scores_list[:, 0] > self.hamming_radius)[0]
-        else:
-            idxs = np.where(scores_list[:, 0] < self.score_thres)[0]
-        for idx in idxs:
-            preds[idx] = {"score": None, "label": None}
-        return preds
-
-
-class FaissBuilder:
-
-    SUPPORT_METRIC_TYPE = ("hamming", "IP", "L2")
-    SUPPORT_INDEX_TYPE = ("Flat", "IVF", "HNSW32")
-    BINARY_METRIC_TYPE = ("hamming",)
-    BINARY_SUPPORT_INDEX_TYPE = ("Flat", "IVF", "BinaryHash")
-
-    @classmethod
-    def _get_index_type(cls, metric_type, index_type, num=None):
-        # if IVF method, cal ivf number automaticlly
-        if index_type == "IVF":
-            index_type = index_type + str(min(int(num // 8), 65536))
-            if metric_type in cls.BINARY_METRIC_TYPE:
-                index_type += ",BFlat"
-            else:
-                index_type += ",Flat"
-
-        # for binary index, add B at head of index_type
-        if metric_type in cls.BINARY_METRIC_TYPE:
-            assert (
-                index_type in cls.BINARY_SUPPORT_INDEX_TYPE
-            ), f"The metric type({metric_type}) only support {cls.BINARY_SUPPORT_INDEX_TYPE} index types!"
-            index_type = "B" + index_type
-
-        if index_type == "HNSW32":
-            logging.warning("The HNSW32 method dose not support 'remove' operation")
-            index_type = "HNSW32"
-
-        if index_type == "Flat":
-            index_type = "Flat"
-
-        return index_type
-
-    @classmethod
-    def _get_metric_type(cls, metric_type):
-        if metric_type == "hamming":
-            return faiss.METRIC_Hamming
-        elif metric_type == "jaccard":
-            return faiss.METRIC_Jaccard
-        elif metric_type == "IP":
-            return faiss.METRIC_INNER_PRODUCT
-        elif metric_type == "L2":
-            return faiss.METRIC_L2
-
-    @classmethod
-    def build(
-        cls,
-        gallery_imgs,
-        gallery_label,
-        predict_func,
-        metric_type="IP",
-        index_type="HNSW32",
-    ):
-        assert (
-            index_type in cls.SUPPORT_INDEX_TYPE
-        ), f"Supported index types only: {cls.SUPPORT_INDEX_TYPE}!"
-
-        assert (
-            metric_type in cls.SUPPORT_METRIC_TYPE
-        ), f"Supported metric types only: {cls.SUPPORT_METRIC_TYPE}!"
-
-        if isinstance(gallery_label, str):
-            gallery_docs, gallery_list = cls.load_gallery(gallery_label, gallery_imgs)
-        else:
-            gallery_docs, gallery_list = gallery_label, gallery_imgs
-
-        features = [res["feature"] for res in predict_func(gallery_list)]
-        dtype = np.uint8 if metric_type in cls.BINARY_METRIC_TYPE else np.float32
-        features = np.array(features).astype(dtype)
-        vector_num, vector_dim = features.shape
-
-        if metric_type in cls.BINARY_METRIC_TYPE:
-            index = faiss.index_binary_factory(
-                vector_dim,
-                cls._get_index_type(metric_type, index_type, vector_num),
-                cls._get_metric_type(metric_type),
-            )
-        else:
-            index = faiss.index_factory(
-                vector_dim,
-                cls._get_index_type(metric_type, index_type, vector_num),
-                cls._get_metric_type(metric_type),
-            )
-            index = faiss.IndexIDMap2(index)
-        ids = {}
-
-        # calculate id for new data
-        index, ids = cls._add_gallery(
-            metric_type, index, ids, features, gallery_docs, mode="new"
-        )
-        return IndexData(
-            index, {"id_map": ids, "metric_type": metric_type, "index_type": index_type}
-        )
-
-    @classmethod
-    def remove(
-        cls,
-        remove_ids,
-        index,
-    ):
-        index, ids, metric_type, index_type = IndexData.load(index)
-        if index_type == "HNSW32":
-            raise RuntimeError(
-                "The index_type: HNSW32 dose not support 'remove' operation"
-            )
-        if isinstance(remove_ids, str):
-            lines = []
-            with open(remove_ids) as f:
-                lines = f.readlines()
-            remove_ids = []
-            for line in lines:
-                id_ = int(line.strip().split(" ")[0])
-                remove_ids.append(id_)
-            remove_ids = np.asarray(remove_ids)
-        else:
-            remove_ids = np.asarray(remove_ids)
-
-        # remove ids in id_map, remove index data in faiss index
-        index.remove_ids(remove_ids)
-        ids = {k: v for k, v in ids.items() if k not in remove_ids}
-        return IndexData(
-            index, {"id_map": ids, "metric_type": metric_type, "index_type": index_type}
-        )
-
-    @classmethod
-    def append(cls, gallery_imgs, gallery_label, predict_func, index):
-        index, ids, metric_type, index_type = IndexData.load(index)
-        assert (
-            metric_type in cls.SUPPORT_METRIC_TYPE
-        ), f"Supported metric types only: {cls.SUPPORT_METRIC_TYPE}!"
-
-        if isinstance(gallery_label, str):
-            gallery_docs, gallery_list = cls.load_gallery(gallery_label, gallery_imgs)
-        else:
-            gallery_docs, gallery_list = gallery_label, gallery_imgs
-
-        features = [res["feature"] for res in predict_func(gallery_list)]
-        dtype = np.uint8 if metric_type in cls.BINARY_METRIC_TYPE else np.float32
-        features = np.array(features).astype(dtype)
-
-        # calculate id for new data
-        index, ids = cls._add_gallery(
-            metric_type, index, ids, features, gallery_docs, mode="append"
-        )
-        return IndexData(
-            index, {"id_map": ids, "metric_type": metric_type, "index_type": index_type}
-        )
-
-    @classmethod
-    def _add_gallery(
-        cls, metric_type, index, ids, gallery_features, gallery_docs, mode
-    ):
-        start_id = max(ids.keys()) + 1 if ids else 0
-        ids_now = (np.arange(0, len(gallery_docs)) + start_id).astype(np.int64)
-
-        # only train when new index file
-        if mode == "new":
-            if metric_type in cls.BINARY_METRIC_TYPE:
-                index.add(gallery_features)
-            else:
-                index.train(gallery_features)
-
-        if metric_type not in cls.BINARY_METRIC_TYPE:
-            index.add_with_ids(gallery_features, ids_now)
-        # TODO(gaotingquan): how append when using hamming metric type
-        # else:
-        #   pass
-
-        for i, d in zip(list(ids_now), gallery_docs):
-            ids[i] = d
-        return index, ids
-
-    @classmethod
-    def load_gallery(cls, gallery_label_path, gallery_imgs_root="", delimiter=" "):
-        lines = []
-        files = []
-        labels = []
-        root = Path(gallery_imgs_root)
-        with open(gallery_label_path, "r", encoding="utf-8") as f:
-            lines = f.readlines()
-        for line in lines:
-            path, label = line.strip().split(delimiter)
-            file_path = root / path
-            files.append(file_path.as_posix())
-            labels.append(label)
-        return labels, files