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

paddlex/modules/base/evaluator.py

@@ -17,7 +17,11 @@ from pathlib import Path
 from abc import ABC, abstractmethod
 
 from .build_model import build_model
-from ...utils.device import update_device_num, set_env_for_device
+from ...utils.device import (
+    update_device_num,
+    set_env_for_device,
+    check_supported_device,
+)
 from ...utils.misc import AutoRegisterABCMetaClass
 from ...utils.config import AttrDict
 from ...utils.logging import *
@@ -33,6 +37,10 @@ def build_evaluater(config: AttrDict) -> "BaseEvaluator":
         BaseEvaluator: the evaluater, which is subclass of BaseEvaluator.
     """
     model_name = config.Global.model
+    try:
+        import feature_line_modules
+    except ModuleNotFoundError:
+        pass
     return BaseEvaluator.get(model_name)(config)
 
 
@@ -52,6 +60,8 @@ class BaseEvaluator(ABC, metaclass=AutoRegisterABCMetaClass):
         self.eval_config = config.Evaluate
 
         config_path = self.get_config_path(self.eval_config.weight_path)
+        if self.eval_config.get("basic_config_path", None):
+            config_path = self.eval_config.get("basic_config_path", None)
 
         self.pdx_config, self.pdx_model = build_model(
             self.global_config.model, config_path=config_path
@@ -138,10 +148,16 @@ evaling!"
         Returns:
             str: device setting, such as: `gpu:0,1`, `npu:0,1`, `cpu`.
         """
+        check_supported_device(self.global_config.device, self.global_config.model)
         set_env_for_device(self.global_config.device)
-        if using_device_number:
-            return update_device_num(self.global_config.device, using_device_number)
-        return self.global_config.device
+        device_setting = (
+            update_device_num(self.global_config.device, using_device_number)
+            if using_device_number
+            else self.global_config.device
+        )
+        # replace "dcu" with "gpu"
+        device_setting = device_setting.replace("dcu", "gpu")
+        return device_setting
 
     @abstractmethod
     def update_config(self):

paddlex/modules/base/exportor.py

@@ -17,7 +17,11 @@ from pathlib import Path
 from abc import ABC, abstractmethod
 
 from .build_model import build_model
-from ...utils.device import update_device_num, set_env_for_device
+from ...utils.device import (
+    update_device_num,
+    set_env_for_device,
+    check_supported_device,
+)
 from ...utils.misc import AutoRegisterABCMetaClass
 from ...utils.config import AttrDict
 from ...utils import logging
@@ -33,6 +37,10 @@ def build_exportor(config: AttrDict) -> "BaseExportor":
         BaseExportor: the exportor, which is subclass of BaseExportor.
     """
     model_name = config.Global.model
+    try:
+        import feature_line_modules
+    except ModuleNotFoundError:
+        pass
     return BaseExportor.get(model_name)(config)
 
 
@@ -52,6 +60,8 @@ class BaseExportor(ABC, metaclass=AutoRegisterABCMetaClass):
         self.export_config = config.Export
 
         config_path = self.get_config_path(self.export_config.weight_path)
+        if self.export_config.get("basic_config_path", None):
+            config_path = self.export_config.get("basic_config_path", None)
 
         self.pdx_config, self.pdx_model = build_model(
             self.global_config.model, config_path=config_path
@@ -70,7 +80,12 @@ class BaseExportor(ABC, metaclass=AutoRegisterABCMetaClass):
         """
 
         config_path = Path(weight_path).parent / "config.yaml"
-        if not config_path.exists():
+        # `Path("https://xxx/xxx")` would cause error on Windows
+        try:
+            is_exists = config_path.exists()
+        except Exception:
+            is_exists = False
+        if not is_exists:
             logging.warning(
                 f"The config file(`{config_path}`) related to weight file(`{weight_path}`) is not exist, use default instead."
             )
@@ -103,10 +118,16 @@ exporting!"
         Returns:
             str: device setting, such as: `gpu:0,1`, `npu:0,1`, `cpu`.
         """
+        check_supported_device(self.global_config.device, self.global_config.model)
         set_env_for_device(self.global_config.device)
-        if using_device_number:
-            return update_device_num(self.global_config.device, using_device_number)
-        return self.global_config.device
+        device_setting = (
+            update_device_num(self.global_config.device, using_device_number)
+            if using_device_number
+            else self.global_config.device
+        )
+        # replace "dcu" with "gpu"
+        device_setting = device_setting.replace("dcu", "gpu")
+        return device_setting
 
     def update_config(self):
         """update export config"""
@@ -114,8 +135,12 @@ exporting!"
 
     def get_export_kwargs(self):
         """get key-value arguments of model export function"""
+        export_with_pir = self.global_config.get("export_with_pir", False) or os.getenv(
+            "FLAGS_json_format_model"
+        ) in ["1", "True"]
         return {
             "weight_path": self.export_config.weight_path,
             "save_dir": self.global_config.output,
             "device": self.get_device(1),
+            "export_with_pir": export_with_pir,
         }

paddlex/modules/base/trainer.py

@@ -16,9 +16,14 @@ import os
 from abc import ABC, abstractmethod
 from pathlib import Path
 from .build_model import build_model
-from ...utils.device import update_device_num, set_env_for_device
+from ...utils.device import (
+    update_device_num,
+    set_env_for_device,
+    check_supported_device,
+)
 from ...utils.misc import AutoRegisterABCMetaClass
 from ...utils.config import AttrDict
+from ...utils.logging import info
 
 
 def build_trainer(config: AttrDict) -> "BaseTrainer":
@@ -31,6 +36,10 @@ def build_trainer(config: AttrDict) -> "BaseTrainer":
         BaseTrainer: the trainer, which is subclass of BaseTrainer.
     """
     model_name = config.Global.model
+    try:
+        import feature_line_modules
+    except ModuleNotFoundError:
+        pass
     return BaseTrainer.get(model_name)(config)
 
 
@@ -49,9 +58,13 @@ class BaseTrainer(ABC, metaclass=AutoRegisterABCMetaClass):
         self.config = config
         self.global_config = config.Global
         self.train_config = config.Train
+        self.eval_config = config.Evaluate
         self.benchmark_config = config.get("Benchmark", None)
+        config_path = self.train_config.get("basic_config_path", None)
 
-        self.pdx_config, self.pdx_model = build_model(self.global_config.model)
+        self.pdx_config, self.pdx_model = build_model(
+            self.global_config.model, config_path=config_path
+        )
 
     def train(self, *args, **kwargs):
         """execute model training"""
@@ -61,11 +74,15 @@ class BaseTrainer(ABC, metaclass=AutoRegisterABCMetaClass):
         train_args = self.get_train_kwargs()
         if self.benchmark_config is not None:
             train_args.update({"benchmark": self.benchmark_config})
+        export_with_pir = self.global_config.get("export_with_pir", False) or os.getenv(
+            "FLAGS_json_format_model"
+        ) in ["1", "True"]
         train_args.update(
             {
                 "uniform_output_enabled": self.train_config.get(
                     "uniform_output_enabled", True
-                )
+                ),
+                "export_with_pir": export_with_pir,
             }
         )
         train_result = self.pdx_model.train(**train_args)
@@ -95,10 +112,16 @@ training!"
         Returns:
             str: device setting, such as: `gpu:0,1`, `npu:0,1` `cpu`.
         """
+        check_supported_device(self.global_config.device, self.global_config.model)
         set_env_for_device(self.global_config.device)
-        if using_device_number:
-            return update_device_num(self.global_config.device, using_device_number)
-        return self.global_config.device
+        device_setting = (
+            update_device_num(self.global_config.device, using_device_number)
+            if using_device_number
+            else self.global_config.device
+        )
+        # replace "dcu" with "gpu"
+        device_setting = device_setting.replace("dcu", "gpu")
+        return device_setting
 
     @abstractmethod
     def update_config(self):

paddlex/modules/face_recognition/trainer.py

@@ -36,15 +36,11 @@ class FaceRecTrainer(ClsTrainer):
 
         self.update_dataset_cfg()
         if self.train_config.num_classes is not None:
-            self.update_num_classes(self.train_config.num_classes)
+            self.pdx_config.update_num_classes(self.train_config.num_classes)
         if self.train_config.pretrain_weight_path != "":
             self.pdx_config.update_pretrained_weights(
                 self.train_config.pretrain_weight_path
             )
-        
-        self.update_arcmargin_cfg(self.train_config.arcmargin_m, 
-                                  self.train_config.arcmargin_s,
-                                  self.train_config.feature_dim)
 
         label_dict_path = Path(self.global_config.dataset_dir).joinpath("label.txt")
         if label_dict_path.exists():
@@ -77,21 +73,3 @@ class FaceRecTrainer(ClsTrainer):
             f"DataLoader.Eval.dataset.pair_label_path={val_list_path}",
         ]
         self.pdx_config.update(ds_cfg)
-    
-    def update_arcmargin_cfg(self, m, s, dim):
-        mg_cfg = [
-            f"Arch.Head.margin={m}",
-            f"Arch.Head.scale={s}",
-        ]
-        if self.pdx_config.model_name == 'MobileFaceNet':
-            mg_cfg.append(f"Arch.Backbone.num_features={dim}")
-        elif self.pdx_config.model_name == 'ResNet50_face':
-            mg_cfg.append(f"Arch.Backbone.class_num={dim}")
-        mg_cfg.append(f"Arch.Head.embedding_size={dim}")
-
-        self.pdx_config.update(mg_cfg)
-
-    def update_num_classes(self, num_classes):
-        nc_cfg = [f"Arch.Head.class_num={num_classes}"]
-        self.pdx_config.update(nc_cfg)
- 

paddlex/modules/formula_recognition/__init__.py

@@ -11,3 +11,8 @@
 # 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 .dataset_checker import FormulaRecDatasetChecker
+from .trainer import FormulaRecTrainer
+from .evaluator import FormulaRecEvaluator
+from .exportor import FormulaRecExportor

paddlex/modules/formula_recognition/dataset_checker/__init__.py

@@ -0,0 +1,113 @@
+# 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 BaseDatasetChecker
+from .dataset_src import check, split_dataset, deep_analyse, convert
+
+from ..model_list import MODELS
+
+
+class FormulaRecDatasetChecker(BaseDatasetChecker):
+    """Dataset Checker for Text Recognition Model"""
+
+    entities = MODELS
+    sample_num = 10
+
+    def get_dataset_root(self, dataset_dir: str) -> str:
+        """find the dataset root dir
+
+        Args:
+            dataset_dir (str): the directory that contain dataset.
+
+        Returns:
+            str: the root directory of dataset.
+        """
+        anno_dirs = list(Path(dataset_dir).glob("**/train.txt"))
+        assert len(anno_dirs) == 1
+        dataset_dir = anno_dirs[0].parent.as_posix()
+        return dataset_dir
+
+    def convert_dataset(self, src_dataset_dir: str) -> str:
+        """convert the dataset from other type to specified type
+
+        Args:
+            src_dataset_dir (str): the root directory of dataset.
+
+        Returns:
+            str: the root directory of converted dataset.
+        """
+        return convert(
+            self.check_dataset_config.convert.src_dataset_type, src_dataset_dir
+        )
+
+    def split_dataset(self, src_dataset_dir: str) -> str:
+        """repartition the train and validation dataset
+
+        Args:
+            src_dataset_dir (str): the root directory of dataset.
+
+        Returns:
+            str: the root directory of splited dataset.
+        """
+        return split_dataset(
+            src_dataset_dir,
+            self.check_dataset_config.split.train_percent,
+            self.check_dataset_config.split.val_percent,
+        )
+
+    def check_dataset(self, dataset_dir: str, sample_num: int = sample_num) -> 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,
+            self.global_config.output,
+            sample_num=10,
+            dataset_type=self.get_dataset_type(),
+        )
+
+    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.
+        """
+        datatype = "FormulaRecDataset"
+        return deep_analyse(dataset_dir, self.output, datatype=datatype)
+
+    def get_show_type(self) -> str:
+        """get the show type of dataset
+
+        Returns:
+            str: show type
+        """
+        return "image"
+
+    def get_dataset_type(self) -> str:
+        """return the dataset type
+
+        Returns:
+            str: dataset type
+        """
+        return "FormulaRecDataset"

paddlex/modules/formula_recognition/dataset_checker/dataset_src/__init__.py

@@ -0,0 +1,19 @@
+# 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 .convert_dataset import convert
+from .split_dataset import split_dataset
+from .analyse_dataset import deep_analyse

paddlex/modules/formula_recognition/dataset_checker/dataset_src/analyse_dataset.py

@@ -0,0 +1,157 @@
+# 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 math
+import platform
+from pathlib import Path
+
+from collections import defaultdict
+from PIL import Image
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.backends.backend_agg import FigureCanvasAgg
+from matplotlib import font_manager
+
+from .....utils.file_interface import custom_open
+from .....utils.logging import warning
+from .....utils.fonts import PINGFANG_FONT_FILE_PATH
+
+
+def simple_analyse(dataset_path, images_dict):
+    """
+    Analyse the dataset samples by return image path and label path
+
+    Args:
+        dataset_path (str): dataset path
+        ds_meta (dict): dataset meta
+        images_dict (dict): train, val and test image path
+
+    Returns:
+        tuple: tuple of sample number, image path and label path for train, val and text subdataset.
+
+    """
+    tags = ["train", "val", "test"]
+    sample_cnts = defaultdict(int)
+    img_paths = defaultdict(list)
+    res = [None] * 6
+
+    for tag in tags:
+        file_list = os.path.join(dataset_path, f"{tag}.txt")
+        if not os.path.exists(file_list):
+            if tag in ("train", "val"):
+                res.insert(0, "数据集不符合规范，请先通过数据校准")
+                return res
+            else:
+                continue
+        else:
+            with custom_open(file_list, "r") as f:
+                all_lines = f.readlines()
+
+            # Each line corresponds to a sample
+            sample_cnts[tag] = len(all_lines)
+            img_paths[tag] = images_dict[tag]
+
+    return (
+        "完成数据分析",
+        sample_cnts[tags[0]],
+        sample_cnts[tags[1]],
+        sample_cnts[tags[2]],
+        img_paths[tags[0]],
+        img_paths[tags[1]],
+        img_paths[tags[2]],
+    )
+
+
+def deep_analyse(dataset_path, output, datatype="FormulaRecDataset"):
+    """class analysis for dataset"""
+    tags = ["train", "val"]
+    all_instances = 0
+    labels_cnt = {}
+    x_max = []
+    classes_max = []
+    for tag in tags:
+        image_path = os.path.join(dataset_path, f"{tag}.txt")
+        str_nums = []
+        with custom_open(image_path, "r") as f:
+            lines = f.readlines()
+        for line in lines:
+            line = line.strip().split("\t")
+            if len(line) != 2:
+                warning(f"Error in {line}.")
+                continue
+            str_nums.append(len(line[1]))
+
+        max_length = min(768, max(str_nums))
+        interval = 20
+
+        start = 0
+        for i in range(1, math.ceil((max_length / interval))):
+            stop = i * interval
+            num_str = sum(start < i <= stop for i in str_nums)
+            labels_cnt[f"{start}-{stop}"] = num_str
+            start = stop
+        if sum(max_length < i for i in str_nums) != 0:
+            labels_cnt[f"> {max_length}"] = sum(max_length < i for i in str_nums)
+        if tag == "train":
+            cnts_train = [cat_ids for cat_name, cat_ids in labels_cnt.items()]
+            x_train = np.arange(len(cnts_train))
+            if len(x_train) > len(x_max):
+                x_max = x_train
+                classes_max = [cat_name for cat_name, cat_ids in labels_cnt.items()]
+        elif tag == "val":
+            cnts_val = [cat_ids for cat_name, cat_ids in labels_cnt.items()]
+            x_val = np.arange(len(cnts_val))
+            if len(x_val) > len(x_max):
+                x_max = x_val
+                classes_max = [cat_name for cat_name, cat_ids in labels_cnt.items()]
+
+    width = 0.3
+
+    # 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, size=15)
+
+    fig, ax = plt.subplots(figsize=(15, 9), dpi=120)
+    xlabel_name = "公式长度区间"
+
+    ax.bar(x_train, cnts_train, width=0.3, label="train")
+    ax.bar(x_val + width, cnts_val, width=0.3, label="val")
+    plt.xticks(x_max + width / 2, classes_max, rotation=90)
+    plt.legend(prop={"size": 18})
+    ax.set_xlabel(
+        xlabel_name,
+        fontproperties=None if os_system == "windows" else font,
+        fontsize=12,
+    )
+    ax.set_ylabel(
+        "图片数量", fontproperties=None if os_system == "windows" else font, fontsize=12
+    )
+
+    canvas = FigureCanvasAgg(fig)
+    canvas.draw()
+    width, height = fig.get_size_inches() * fig.get_dpi()
+    pie_array = np.frombuffer(canvas.tostring_rgb(), dtype="uint8").reshape(
+        int(height), int(width), 3
+    )
+    fig1_path = os.path.join(output, "histogram.png")
+    cv2.imwrite(fig1_path, pie_array)
+
+    return {"histogram": os.path.join("check_dataset", "histogram.png")}

paddlex/modules/formula_recognition/dataset_checker/dataset_src/check_dataset.py

@@ -0,0 +1,80 @@
+# 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
+from collections import defaultdict
+
+from PIL import Image
+import json
+import numpy as np
+
+from .....utils.errors import DatasetFileNotFoundError, CheckFailedError
+
+
+def check(
+    dataset_dir, output, dataset_type=" FormulaRecDataset", mode="fast", sample_num=10
+):
+    """check dataset"""
+    if dataset_type == "FormulaRecDataset":
+        # Custom dataset
+        if not osp.exists(dataset_dir) or not osp.isdir(dataset_dir):
+            raise DatasetFileNotFoundError(file_path=dataset_dir)
+        tags = ["train", "val"]
+        delim = "\t"
+        valid_num_parts = 2
+        max_recorded_sample_cnts = 50
+        sample_cnts = dict()
+        sample_paths = defaultdict(list)
+        for tag in tags:
+            file_list = osp.join(dataset_dir, f"{tag}.txt")
+            if not osp.exists(file_list):
+                if tag in ("train", "val"):
+                    # train and val file lists must exist
+                    raise DatasetFileNotFoundError(
+                        file_path=file_list,
+                        solution=f"Ensure that both `train.txt` and `val.txt` exist in {dataset_dir}",
+                    )
+                else:
+                    continue
+            else:
+                with open(file_list, "r", encoding="utf-8") as f:
+                    all_lines = f.readlines()
+                    sample_cnts[tag] = len(all_lines)
+                    for line in all_lines:
+                        substr = line.strip("\n").split(delim)
+                        if len(line.strip("\n")) < 1:
+                            continue
+                        if len(substr) != valid_num_parts and len(line.strip("\n")) > 1:
+                            raise CheckFailedError(
+                                f"Error in {line}, The number of delimiter-separated items in each row "
+                                "in {file_list} should be {valid_num_parts} (current delimiter is '{delim}')."
+                            )
+                        file_name = substr[0]
+                        img_path = osp.join(dataset_dir, file_name)
+                        if len(sample_paths[tag]) < max_recorded_sample_cnts:
+                            sample_paths[tag].append(os.path.relpath(img_path, output))
+
+                        if not os.path.exists(img_path):
+                            raise DatasetFileNotFoundError(file_path=img_path)
+
+        meta = {}
+        meta["train_samples"] = sample_cnts["train"]
+        meta["train_sample_paths"] = sample_paths["train"][:sample_num]
+
+        meta["val_samples"] = sample_cnts["val"]
+        meta["val_sample_paths"] = sample_paths["val"][:sample_num]
+
+        return meta