paddlex 2.0.0rc4__py3-none-any.whl → 3.0.0b2__py3-none-any.whl

paddlex/configs/vehicle_attribute/PP-LCNet_x1_0_vehicle_attribute.yaml

@@ -0,0 +1,41 @@
+Global:
+  model: PP-LCNet_x1_0_vehicle_attribute
+  mode: check_dataset # check_dataset/train/evaluate/predict
+  dataset_dir: dataset/vehicle_attribute_examples
+  device: gpu:0,1,2,3
+  output: "output"
+
+CheckDataset:
+  convert: 
+    enable: False
+    src_dataset_type: null
+  split: 
+    enable: False
+    train_percent: null
+    val_percent: null
+
+Train:
+  num_classes: 19
+  epochs_iters: 20
+  batch_size: 64
+  learning_rate: 0.0008
+  pretrain_weight_path: https://paddle-model-ecology.bj.bcebos.com/paddlex/official_pretrained_model/PP-LCNet_x1_0_vehicle_attribute_pretrained.pdparams
+  warmup_steps: 5
+  resume_path: null
+  log_interval: 20
+  eval_interval: 1
+  save_interval: 1
+
+Evaluate:
+  weight_path: "output/best_model/best_model.pdparams"
+  log_interval: 1
+
+Export:
+  weight_path: https://paddle-model-ecology.bj.bcebos.com/paddlex/official_pretrained_model/PP-LCNet_x1_0_vehicle_attribute_pretrained.pdparams
+
+Predict:
+  batch_size: 1
+  model_dir: "output/best_model/inference"
+  input: "https://paddle-model-ecology.bj.bcebos.com/paddlex/imgs/demo_image/vehicle_attribute_007.jpg"
+  kernel_option:
+    run_mode: paddle

paddlex/configs/vehicle_detection/PP-YOLOE-L_vehicle.yaml

@@ -0,0 +1,41 @@
+Global:
+  model: PP-YOLOE-L_vehicle
+  mode: check_dataset # check_dataset/train/evaluate/predict
+  dataset_dir: "/paddle/dataset/paddlex/det/vehicle_coco_examples"
+  device: gpu:0,1,2,3
+  output: "output"
+
+CheckDataset:
+  convert:
+    enable: False
+    src_dataset_type: null
+  split:
+    enable: False
+    train_percent: null
+    val_percent: null
+
+Train:
+  num_classes: 4
+  epochs_iters: 50
+  batch_size: 2
+  learning_rate: 0.001
+  pretrain_weight_path: https://paddle-model-ecology.bj.bcebos.com/paddlex/official_pretrained_model/PP-YOLOE-L_vehicle_pretrained.pdparams
+  warmup_steps: 100
+  resume_path: null
+  log_interval: 10
+  eval_interval: 1
+
+Evaluate:
+  weight_path: "output/best_model/best_model.pdparams"
+  log_interval: 10
+
+Predict:
+  batch_size: 1
+  model_dir: "output/best_model/inference"
+  input: "https://paddle-model-ecology.bj.bcebos.com/paddlex/imgs/demo_image/vehicle_detection.jpg"
+  kernel_option:
+    run_mode: paddle
+
+
+Export:
+  weight_path: https://paddle-model-ecology.bj.bcebos.com/paddlex/official_pretrained_model/PP-YOLOE-L_vehicle_pretrained.pdparams

paddlex/configs/vehicle_detection/PP-YOLOE-S_vehicle.yaml

@@ -0,0 +1,42 @@
+Global:
+  model: PP-YOLOE-S_vehicle
+  mode: check_dataset # check_dataset/train/evaluate/predict
+  dataset_dir: "/paddle/dataset/paddlex/det/vehicle_coco_examples"
+  device: gpu:0,1,2,3
+  output: "output"
+
+CheckDataset:
+  convert:
+    enable: False
+    src_dataset_type: null
+  split:
+    enable: False
+    train_percent: null
+    val_percent: null
+
+Train:
+  num_classes: 4
+  epochs_iters: 50
+  batch_size: 2
+  learning_rate: 0.001
+  pretrain_weight_path: https://paddle-model-ecology.bj.bcebos.com/paddlex/official_pretrained_model/PP-YOLOE-S_vehicle_pretrained.pdparams
+  warmup_steps: 100
+  resume_path: null
+  log_interval: 10
+  eval_interval: 1
+
+Evaluate:
+  weight_path: "output/best_model/best_model.pdparams"
+  log_interval: 10
+
+Predict:
+  batch_size: 1
+  model_dir: "output/best_model/inference"
+  input: "https://paddle-model-ecology.bj.bcebos.com/paddlex/imgs/demo_image/vehicle_detection.jpg"
+  kernel_option:
+    run_mode: paddle
+
+
+
+Export:
+  weight_path: https://paddle-model-ecology.bj.bcebos.com/paddlex/official_pretrained_model/PP-YOLOE-S_vehicle_pretrained.pdparams

paddlex/engine.py

@@ -0,0 +1,54 @@
+# 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 .utils.lazy_loader import disable_pir_bydefault
+from .utils.result_saver import try_except_decorator
+from .utils.config import parse_args, get_config
+from .utils.errors import raise_unsupported_api_error
+from .model import _ModelBasedConfig
+
+
+class Engine(object):
+    """Engine"""
+
+    def __init__(self):
+        args = parse_args()
+        config = get_config(args.config, overrides=args.override, show=False)
+        self._mode = config.Global.mode
+        self._output = config.Global.output
+        self._model = _ModelBasedConfig(config)
+
+    @try_except_decorator
+    def run(self):
+        """the main function"""
+        if self._mode == "check_dataset":
+            return self._model.check_dataset()
+        elif self._mode == "train":
+            disable_pir_bydefault()
+            self._model.train()
+        elif self._mode == "evaluate":
+            disable_pir_bydefault()
+            return self._model.evaluate()
+        elif self._mode == "export":
+            disable_pir_bydefault()
+            return self._model.export()
+        elif self._mode == "predict":
+            for res in self._model.predict():
+                res.print(json_format=False)
+                if self._output:
+                    res.save_all(save_path=self._output)
+        else:
+            raise_unsupported_api_error(f"{self._mode}", self.__class__)

paddlex/inference/__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 .models import create_predictor
+from .pipelines import create_pipeline
+from .utils.pp_option import PaddlePredictorOption

paddlex/inference/components/__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 .transforms import *
+from .paddle_predictor import *
+from .task_related import *
+from .retrieval import *

paddlex/inference/components/base.py

@@ -0,0 +1,292 @@
+# 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 inspect
+from abc import ABC, abstractmethod
+from copy import deepcopy
+from types import GeneratorType
+
+from ...utils.flags import INFER_BENCHMARK
+from ...utils import logging
+from ..utils.benchmark import Timer
+
+
+class BaseComponent(ABC):
+
+    YIELD_BATCH = True
+    KEEP_INPUT = True
+    ENABLE_BATCH = False
+
+    INPUT_KEYS = None
+    OUTPUT_KEYS = None
+
+    def __init__(self):
+        self.inputs = self.DEAULT_INPUTS if hasattr(self, "DEAULT_INPUTS") else {}
+        self.outputs = self.DEAULT_OUTPUTS if hasattr(self, "DEAULT_OUTPUTS") else {}
+
+        if INFER_BENCHMARK:
+            self.timer = Timer()
+            self.apply = self.timer.watch_func(self.apply)
+
+    def __call__(self, input_list):
+        # use list type for batched data
+        if not isinstance(input_list, list):
+            input_list = [input_list]
+
+        output_list = []
+        for args, input_ in self._check_input(input_list):
+            output = self.apply(**args)
+            if not output:
+                if self.YIELD_BATCH:
+                    yield input_list
+                else:
+                    for item in input_list:
+                        yield item
+
+            # output may be a generator, when the apply() uses yield
+            if (
+                isinstance(output, GeneratorType)
+                or output.__class__.__name__ == "generator"
+            ):
+                # if output is a generator, use for-in to get every one batch output data and yield one by one
+                for each_output in output:
+                    reassemble_data = self._check_output(each_output, input_)
+                    if self.YIELD_BATCH:
+                        yield reassemble_data
+                    else:
+                        for item in reassemble_data:
+                            yield item
+            # if output is not a generator, process all data of that and yield, so use output_list to collect all reassemble_data
+            else:
+                reassemble_data = self._check_output(output, input_)
+                output_list.extend(reassemble_data)
+
+        # avoid yielding output_list when the output is a generator
+        if len(output_list) > 0:
+            if self.YIELD_BATCH:
+                yield output_list
+            else:
+                for item in output_list:
+                    yield item
+
+    def _check_input(self, input_list):
+        # check if the value of input data meets the requirements of apply(),
+        # and reassemble the parameters of apply() from input_list
+        def _check_type(input_):
+            if not isinstance(input_, dict):
+                if len(self.inputs) == 1:
+                    key = list(self.inputs.keys())[0]
+                    input_ = {key: input_}
+                else:
+                    raise Exception(
+                        f"The input must be a dict or a list of dict, unless the input of the component only requires one argument, but the component({self.__class__.__name__}) requires {list(self.inputs.keys())}!"
+                    )
+            return input_
+
+        def _check_args_key(args):
+            sig = inspect.signature(self.apply)
+            for param in sig.parameters.values():
+                if param.kind == inspect.Parameter.VAR_KEYWORD:
+                    logging.debug(
+                        f"The apply function parameter of {self.__class__.__name__} is **kwargs, so would not inspect!"
+                    )
+                    continue
+                if param.default == inspect.Parameter.empty and param.name not in args:
+                    raise Exception(
+                        f"The parameter ({param.name}) is needed by {self.__class__.__name__}, but {list(args.keys())} only found!"
+                    )
+
+        if self.inputs is None:
+            return [({}, None)]
+
+        if self.need_batch_input:
+            args = {}
+            for input_ in input_list:
+                input_ = _check_type(input_)
+                for k, v in self.inputs.items():
+                    if v not in input_:
+                        raise Exception(
+                            f"The value ({v}) is needed by {self.__class__.__name__}. But not found in Data ({input_.keys()})!"
+                        )
+                    if k not in args:
+                        args[k] = []
+                    args[k].append(input_.get(v))
+                _check_args_key(args)
+            reassemble_input = [(args, input_list)]
+        else:
+            reassemble_input = []
+            for input_ in input_list:
+                input_ = _check_type(input_)
+                args = {}
+                for k, v in self.inputs.items():
+                    if v not in input_:
+                        raise Exception(
+                            f"The value ({v}) is needed by {self.__class__.__name__}. But not found in Data ({input_.keys()})!"
+                        )
+                    args[k] = input_.get(v)
+                _check_args_key(args)
+                reassemble_input.append((args, input_))
+        return reassemble_input
+
+    def _check_output(self, output, ori_data):
+        # check if the value of apply() output data meets the requirements of setting
+        # when the output data is list type, reassemble each of that
+        if isinstance(output, list):
+            if self.need_batch_input:
+                assert isinstance(ori_data, list) and len(ori_data) == len(output)
+                output_list = []
+                for ori_item, output_item in zip(ori_data, output):
+                    data = ori_item.copy() if self.keep_input else {}
+                    if isinstance(self.outputs, type(None)):
+                        logging.debug(
+                            f"The `output_key` of {self.__class__.__name__} is None, so would not inspect!"
+                        )
+                        data.update(output_item)
+                    else:
+                        for k, v in self.outputs.items():
+                            if k not in output_item:
+                                raise Exception(
+                                    f"The value ({k}) is needed by {self.__class__.__name__}. But not found in Data ({output_item.keys()})!"
+                                )
+                            data.update({v: output_item[k]})
+                    output_list.append(data)
+                return output_list
+            else:
+                assert isinstance(ori_data, dict)
+                output_list = []
+                for output_item in output:
+                    data = ori_data.copy() if self.keep_input else {}
+                    if isinstance(self.outputs, type(None)):
+                        logging.debug(
+                            f"The `output_key` of {self.__class__.__name__} is None, so would not inspect!"
+                        )
+                        data.update(output_item)
+                    else:
+                        for k, v in self.outputs.items():
+                            if k not in output_item:
+                                raise Exception(
+                                    f"The value ({k}) is needed by {self.__class__.__name__}. But not found in Data ({output_item.keys()})!"
+                                )
+                            data.update({v: output_item[k]})
+                    output_list.append(data)
+                return output_list
+        else:
+            assert isinstance(ori_data, dict) and isinstance(output, dict)
+            data = ori_data.copy() if self.keep_input else {}
+            if isinstance(self.outputs, type(None)):
+                logging.debug(
+                    f"The `output_key` of {self.__class__.__name__} is None, so would not inspect!"
+                )
+                data.update(output)
+            else:
+                for k, v in self.outputs.items():
+                    if k not in output:
+                        raise Exception(
+                            f"The value of key ({k}) is needed add to Data. But not found in output of {self.__class__.__name__}: ({output.keys()})!"
+                        )
+                    data.update({v: output[k]})
+        return [data]
+
+    def set_inputs(self, inputs):
+        assert isinstance(inputs, dict)
+        input_keys = deepcopy(self.INPUT_KEYS)
+
+        # e.g, input_keys is None or []
+        if input_keys is None or (
+            isinstance(input_keys, list) and len(input_keys) == 0
+        ):
+            self.inputs = {}
+            if inputs:
+                raise Exception
+            return
+
+        # e.g, input_keys is 'img'
+        if not isinstance(input_keys, list):
+            input_keys = [[input_keys]]
+        # e.g, input_keys is ['img'] or [['img']]
+        elif len(input_keys) > 0:
+            # e.g, input_keys is ['img']
+            if not isinstance(input_keys[0], list):
+                input_keys = [input_keys]
+
+        ck_pass = False
+        for key_group in input_keys:
+            for key in key_group:
+                if key not in inputs:
+                    break
+            # check pass
+            else:
+                ck_pass = True
+            if ck_pass == True:
+                break
+        else:
+            raise Exception(
+                f"The input {input_keys} are needed by {self.__class__.__name__}. But only get: {list(inputs.keys())}"
+            )
+        self.inputs = inputs
+
+    def set_outputs(self, outputs):
+        assert isinstance(outputs, dict)
+        output_keys = deepcopy(self.OUTPUT_KEYS)
+        if not isinstance(output_keys, list):
+            output_keys = [output_keys]
+
+        for k in output_keys:
+            if k not in outputs:
+                logging.debug(
+                    f"The output ({k}) of {self.__class__.__name__} would be abandon!"
+                )
+        self.outputs = outputs
+
+    @classmethod
+    def get_input_keys(cls) -> list:
+        return cls.input_keys
+
+    @classmethod
+    def get_output_keys(cls) -> list:
+        return cls.output_keys
+
+    @property
+    def need_batch_input(self):
+        return getattr(self, "ENABLE_BATCH", False)
+
+    @property
+    def keep_input(self):
+        return getattr(self, "KEEP_INPUT", True)
+
+    @property
+    def name(self):
+        return getattr(self, "NAME", self.__class__.__name__)
+
+    @property
+    def sub_cmps(self):
+        return None
+
+    @abstractmethod
+    def apply(self, input):
+        raise NotImplementedError
+
+
+class ComponentsEngine(object):
+    def __init__(self, ops):
+        self.ops = ops
+        self.keys = list(ops.keys())
+
+    def __call__(self, data, i=0):
+        data_gen = self.ops[self.keys[i]](data)
+        if i + 1 < len(self.ops):
+            for data in data_gen:
+                yield from self.__call__(data, i + 1)
+        else:
+            yield from data_gen

paddlex/inference/components/llm/__init__.py

@@ -0,0 +1,25 @@
+# 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 BaseLLM
+from .erniebot import ErnieBot
+
+
+def create_llm_api(model_name: str, params={}) -> BaseLLM:
+    # for CI
+    if model_name == "paddlex_ci":
+        return
+    return BaseLLM.get(model_name)(
+        model_name=model_name,
+        params=params,
+    )

paddlex/inference/components/llm/base.py

@@ -0,0 +1,65 @@
+# 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 base64
+from ..base import BaseComponent
+from ....utils.subclass_register import AutoRegisterABCMetaClass
+
+__all__ = ["BaseLLM"]
+
+
+class BaseLLM(BaseComponent, metaclass=AutoRegisterABCMetaClass):
+    __is_base = True
+
+    ERROR_MASSAGE = ""
+    VECTOR_STORE_PREFIX = "PADDLEX_VECTOR_STORE"
+
+    def __init__(self):
+        super().__init__()
+
+    def pre_process(self, inputs):
+        return inputs
+
+    def post_process(self, outputs):
+        return outputs
+
+    def pred(self, inputs):
+        raise NotImplementedError("The method `pred` has not been implemented yet.")
+
+    def get_vector(self):
+        raise NotImplementedError(
+            "The method `get_vector` has not been implemented yet."
+        )
+
+    def caculate_similar(self):
+        raise NotImplementedError(
+            "The method `caculate_similar` has not been implemented yet."
+        )
+
+    def apply(self, inputs):
+        pre_process_results = self.pre_process(inputs)
+        pred_results = self.pred(pre_process_results)
+        post_process_results = self.post_process(pred_results)
+        return post_process_results
+
+    def is_vector_store(self, s):
+        return s.startswith(self.VECTOR_STORE_PREFIX)
+
+    def encode_vector_store(self, vector_store_bytes):
+        return self.VECTOR_STORE_PREFIX + base64.b64encode(vector_store_bytes).decode(
+            "ascii"
+        )
+
+    def decode_vector_store(self, vector_store_str):
+        return base64.b64decode(vector_store_str[len(self.VECTOR_STORE_PREFIX) :])