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

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

@@ -0,0 +1,217 @@
+# 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 cProfile import label
+import os
+
+from collections import defaultdict
+
+import matplotlib.pyplot as plt
+from matplotlib.backends.backend_agg import FigureCanvasAgg
+import numpy as np
+from PIL import Image, ImageOps
+import cv2
+import json
+
+from .....utils.file_interface import custom_open
+
+
+# show data samples
+def simple_analyse(dataset_path, max_recorded_sample_cnts=20, show_label=True):
+    """
+    Analyse the dataset samples by return not nore than
+    max_recorded_sample_cnts image path and label path
+
+    Args:
+        dataset_path (str): dataset path
+        max_recorded_sample_cnts (int, optional): the number to return. Default: 50.
+
+    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)
+    lab_paths = defaultdict(list)
+    lab_infos = defaultdict(list)
+    res = [None] * 9
+    delim = "\t"
+    valid_num_parts = 2
+
+    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)
+
+            for idx, line in enumerate(all_lines):
+                parts = line.strip("\n").split(delim)
+                if len(line.strip("\n")) < 1:
+                    continue
+                if tag in ("train", "val"):
+                    valid_num_parts_lst = [2]
+                else:
+                    valid_num_parts_lst = [1, 2]
+                if len(parts) not in valid_num_parts_lst and len(line.strip("\n")) > 1:
+                    res.insert(0, "数据集的标注文件不符合规范")
+                    return res
+
+                if len(parts) == 2:
+                    img_path, lab_path = parts
+                else:
+                    # len(parts) == 1
+                    img_path = parts[0]
+                    lab_path = None
+
+                # check det label
+                if len(img_paths[tag]) < max_recorded_sample_cnts:
+                    img_path = os.path.join(dataset_path, img_path)
+                    if lab_path is not None:
+                        label = json.loads(lab_path)
+                        boxes = []
+                        for item in label:
+                            if "points" not in item or "transcription" not in item:
+                                res.insert(0, "数据集的标注文件不符合规范")
+                                return res
+
+                            box = np.array(item["points"])
+                            if box.shape[1] != 2:
+                                res.insert(0, "数据集的标注文件不符合规范")
+                                return res
+                            boxes.append(box)
+                            txt = item["transcription"]
+                            if not isinstance(txt, str):
+                                res.insert(0, "数据集的标注文件不符合规范")
+                                return res
+                        if show_label:
+                            lab_img = show_label_img(img_path, boxes)
+
+                    img_paths[tag].append(img_path)
+                    if show_label:
+                        lab_paths[tag].append(lab_img)
+                    else:
+                        lab_infos[tag].append({"img_path": img_path, "box": boxes})
+
+    if show_label:
+        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]],
+            lab_paths[tags[0]],
+            lab_paths[tags[1]],
+            lab_paths[tags[2]],
+        )
+    else:
+        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]],
+            lab_infos[tags[0]],
+            lab_infos[tags[1]],
+            lab_infos[tags[2]],
+        )
+
+
+def show_label_img(img_path, dt_boxes):
+    """draw ocr detection label"""
+    img = cv2.imread(img_path)
+    for box in dt_boxes:
+        box = np.array(box).astype(np.int32).reshape(-1, 2)
+        cv2.polylines(img, [box], True, color=(0, 255, 0), thickness=3)
+    return img[:, :, ::-1]
+
+
+def deep_analyse(dataset_path, output):
+    """class analysis for dataset"""
+    sample_results = simple_analyse(
+        dataset_path, max_recorded_sample_cnts=float("inf"), show_label=False
+    )
+    lab_infos = sample_results[-3] + sample_results[-2] + sample_results[-1]
+    labels_cnt = defaultdict(int)
+    img_shapes = []  # w, h
+    ratios_w = []
+    ratios_h = []
+    for info in lab_infos:
+        img = np.asarray(ImageOps.exif_transpose(Image.open(info["img_path"])))
+        img_h, img_w = np.shape(img)[:2]
+        img_shapes.append([img_w, img_h])
+        for box in info["box"]:
+            box = np.array(box).astype(np.int32).reshape(-1, 2)
+            box_w, box_h = np.max(box, axis=0) - np.min(box, axis=0)
+            ratio_w = box_w / img_w
+            ratio_h = box_h / img_h
+            ratios_w.append(ratio_w)
+            ratios_h.append(ratio_h)
+    m_w_img, m_h_img = np.mean(img_shapes, axis=0)  # mean img shape
+    m_num_box = len(ratios_w) / len(lab_infos)  # num box per img
+
+    ratio_w = [i * 1000 for i in ratios_w]
+    ratio_h = [i * 1000 for i in ratios_h]
+    w_bins = int((max(ratio_w) - min(ratio_w)) // 10)
+    h_bins = int((max(ratio_h) - min(ratio_h)) // 10)
+
+    fig, ax = plt.subplots()
+    ax.hist(ratio_w, bins=w_bins, rwidth=0.8, color="yellowgreen")
+    ax.set_xlabel("Width rate *1000")
+    ax.set_ylabel("number")
+    canvas = FigureCanvasAgg(fig)
+    canvas.draw()
+    width, height = fig.get_size_inches() * fig.get_dpi()
+    bar_array = np.frombuffer(canvas.tostring_rgb(), dtype="uint8").reshape(
+        int(height), int(width), 3
+    )
+
+    # pie
+    fig, ax = plt.subplots()
+    ax.hist(ratio_h, bins=h_bins, rwidth=0.8, color="pink")
+    ax.set_xlabel("Height rate *1000")
+    ax.set_ylabel("number")
+    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
+    )
+
+    os.makedirs(output, exist_ok=True)
+    fig_path = os.path.join(output, "histogram.png")
+    img_array = np.concatenate((bar_array, pie_array), axis=1)
+    cv2.imwrite(fig_path, img_array)
+    return {"histogram": os.path.join("check_dataset", "histogram.png")}
+    # return {
+    #     "图像平均宽度": m_w_img,
+    #     "图像平均高度": m_h_img,
+    #     "每张图平均文本检测框数量": m_num_box,
+    #     "检测框相对宽度分布图": fig1_path,
+    #     "检测框相对高度分布图": fig2_path
+    # }

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

@@ -0,0 +1,96 @@
+# 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
+
+
+def check(dataset_dir, output, sample_num=10):
+    """check dataset"""
+    dataset_dir = osp.abspath(dataset_dir)
+
+    if not osp.exists(dataset_dir) or not osp.isdir(dataset_dir):
+        raise DatasetFileNotFoundError(file_path=dataset_dir)
+
+    sample_cnts = dict()
+    sample_paths = defaultdict(list)
+    delim = "\t"
+    valid_num_parts = 2
+
+    tags = ["train", "val"]
+    for _, tag in enumerate(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 idx, line in enumerate(all_lines):
+                    substr = line.strip("\n").split(delim)
+                    if len(line.strip("\n")) < 1:
+                        continue
+                    assert (
+                        len(substr) == valid_num_parts or len(line.strip("\n")) <= 1
+                    ), 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]
+                    label = substr[1]
+                    img_path = osp.join(dataset_dir, file_name)
+                    if len(sample_paths[tag]) < sample_num:
+                        sample_paths[tag].append(os.path.relpath(img_path, output))
+                    if not osp.exists(img_path):
+                        raise DatasetFileNotFoundError(file_path=img_path)
+
+                    # check det label
+                    label = json.loads(label)
+                    for item in label:
+                        assert (
+                            "points" in item and "transcription" in item
+                        ), f"line {idx} is not in the correct format."
+                        box = np.array(item["points"])
+                        assert (
+                            box.shape[1] == 2
+                        ), f"{box} in line {idx} is not in the correct format."
+
+                        txt = item["transcription"]
+                        assert isinstance(
+                            txt, str
+                        ), f"{txt} in line {idx} is not in the correct format."
+
+    attrs = {}
+    attrs["train_samples"] = sample_cnts["train"]
+    attrs["train_sample_paths"] = sample_paths["train"][:sample_num]
+
+    attrs["val_samples"] = sample_cnts["val"]
+    attrs["val_sample_paths"] = sample_paths["val"][:sample_num]
+    return attrs

paddlex/modules/text_detection/dataset_checker/dataset_src/split_dataset.py

@@ -0,0 +1,140 @@
+# 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 glob
+import os.path
+import numpy as np
+import shutil
+
+from .....utils.file_interface import custom_open
+from .....utils.logging import info
+
+
+def split_dataset(dataset_root, train_rate, val_rate):
+    """
+    将图像数据集按照比例分成训练集、验证集和测试集，并生成对应的.txt文件。
+
+    Args:
+        dataset_root (str): 数据集根目录路径。
+        train_rate (int): 训练集占总数据集的比例（%）。
+        val_rate (int): 验证集占总数据集的比例（%）。
+
+    Returns:
+        str: 数据划分结果信息。
+    """
+    sum_rate = train_rate + val_rate
+    assert sum_rate == 100, f"训练集、验证集比例之和需要等于100，请修改后重试"
+    assert (
+        train_rate > 0 and val_rate > 0
+    ), f"The train_rate({train_rate}) and val_rate({val_rate}) should be greater than 0!"
+
+    image_dir = os.path.join(dataset_root, "images")
+    tags = ["train.txt", "val.txt"]
+
+    image_files = get_files(image_dir, ["png", "jpg", "jpeg", "PNG", "JPG", "JPEG"])
+    label_files = get_labels_files(dataset_root, ["train.txt", "val.txt"])
+
+    for tag in tags:
+        src_file = os.path.join(dataset_root, tag)
+        dst_file = os.path.join(dataset_root, f"{tag}.bak")
+        info(
+            f"The original annotation file {src_file} has been backed up to {dst_file}."
+        )
+        shutil.move(src_file, dst_file)
+
+    image_num = len(image_files)
+    label_num = len(label_files)
+    assert image_num != 0, f"原始图像数量({image_num})为0, 请检查后重试"
+    assert (
+        image_num == label_num
+    ), f"原始图像数量({image_num})和标注图像数量({label_num})不相等，请检查后重试"
+
+    image_files = np.array(image_files)
+    label_files = np.array(label_files)
+    state = np.random.get_state()
+    np.random.shuffle(image_files)
+    np.random.set_state(state)
+    np.random.shuffle(label_files)
+
+    start = 0
+    rate_list = [train_rate, val_rate]
+    name_list = ["train", "val"]
+    separator = " "
+    for i, name in enumerate(name_list):
+        info("Creating {}.txt...".format(name))
+
+        rate = rate_list[i]
+        if rate == 0:
+            txt_file = os.path.join(dataset_root, name + ".txt")
+            with custom_open(txt_file, "w") as f:
+                f.write("")
+            continue
+
+        end = start + round(image_num * rate / 100)
+        if sum(rate_list[i + 1 :]) == 0:
+            end = image_num
+
+        txt_file = os.path.join(dataset_root, name + ".txt")
+        with custom_open(txt_file, "w") as f:
+            for id in range(start, end):
+                right = label_files[id]
+                f.write(right)
+        start = end
+
+    return dataset_root
+
+
+def get_files(input_dir, format=["jpg", "png"]):
+    """
+    在给定目录下获取符合指定文件格式的所有文件路径
+
+    Args:
+        input_dir (str): 目标文件夹路径
+        format (Union[str, List[str]]): 需要获取的文件格式, 可以是字符串或者字符串列表
+
+    Returns:
+        List[str]: 符合格式的所有文件路径列表，返回排序后的结果
+    """
+    res = []
+    if not isinstance(format, (list, tuple)):
+        format = [format]
+    for item in format:
+        pattern = os.path.join(input_dir, f"**/*.{item}")
+        files = glob.glob(pattern, recursive=True)
+        res.extend(files)
+    return sorted(res)
+
+
+def get_labels_files(input_dir, format=["train.txt", "val.txt"]):
+    """
+    在给定目录下获取符合指定文件格式的所有文件路径
+
+    Args:
+        input_dir (str): 目标文件夹路径
+        format (Union[str, List[str]]): 需要获取的文件格式, 可以是字符串或者字符串列表
+
+    Returns:
+        List[str]: 符合格式的所有文件路径列表，返回排序后的结果
+    """
+    res = []
+    if not isinstance(format, (list, tuple)):
+        format = [format]
+    for tag in format:
+        file_list = os.path.join(input_dir, f"{tag}")
+        if os.path.exists(file_list):
+            with custom_open(file_list, "r") as f:
+                all_lines = f.readlines()
+                res.extend(all_lines)
+    return sorted(res)

paddlex/modules/text_detection/evaluator.py

@@ -0,0 +1,41 @@
+# 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 TextDetEvaluator(BaseEvaluator):
+    """Text Detection Model Evaluator"""
+
+    entities = MODELS
+
+    def update_config(self):
+        """update evalution config"""
+        if self.eval_config.log_interval:
+            self.pdx_config.update_log_interval(self.eval_config.log_interval)
+
+        self.pdx_config.update_dataset(self.global_config.dataset_dir, "TextDetDataset")
+
+    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(),
+        }

paddlex/modules/text_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 TextDetExportor(BaseExportor):
+    """Text Detection Model Exportor"""
+
+    entities = MODELS

paddlex/modules/text_detection/model_list.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.
+
+MODELS = [
+    "PP-OCRv4_mobile_det",
+    "PP-OCRv4_server_det",
+    "PP-OCRv4_mobile_seal_det",
+    "PP-OCRv4_server_seal_det",
+]
+
+CURVE_MODELS = ["PP-OCRv4_mobile_seal_det", "PP-OCRv4_server_seal_det"]

paddlex/modules/text_detection/trainer.py

@@ -0,0 +1,68 @@
+# 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 pathlib import Path
+
+from ..base import BaseTrainer
+from ...utils.config import AttrDict
+from .model_list import MODELS
+
+
+class TextDetTrainer(BaseTrainer):
+    """Text Detection Model Trainer"""
+
+    entities = MODELS
+
+    def update_config(self):
+        """update training config"""
+        if self.train_config.log_interval:
+            self.pdx_config.update_log_interval(self.train_config.log_interval)
+        if self.train_config.eval_interval:
+            self.pdx_config._update_eval_interval_by_epoch(
+                self.train_config.eval_interval
+            )
+        if self.train_config.save_interval:
+            self.pdx_config.update_save_interval(self.train_config.save_interval)
+
+        self.pdx_config.update_dataset(self.global_config.dataset_dir, "TextDetDataset")
+        if self.train_config.pretrain_weight_path:
+            self.pdx_config.update_pretrained_weights(
+                self.train_config.pretrain_weight_path
+            )
+        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)
+        if (
+            self.train_config.resume_path is not None
+            and self.train_config.resume_path != ""
+        ):
+            self.pdx_config._update_checkpoints(self.train_config.resume_path)
+        if self.global_config.output is not None:
+            self.pdx_config._update_output_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.
+        """
+        return {
+            "device": self.get_device(),
+            "dy2st": self.train_config.get("dy2st", False),
+        }

paddlex/modules/text_recognition/__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 .dataset_checker import TextRecDatasetChecker
+from .trainer import TextRecTrainer
+from .evaluator import TextRecEvaluator
+from .exportor import TextRecExportor