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

paddlex/inference/models/common/ts/processors.py

@@ -0,0 +1,313 @@
+# 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 typing import List, Dict, Any
+from pathlib import Path
+from copy import deepcopy
+import joblib
+import numpy as np
+import pandas as pd
+
+from .funcs import load_from_dataframe, time_feature
+
+
+__all__ = [
+    "BuildTSDataset",
+    "TSCutOff",
+    "TSNormalize",
+    "TimeFeature",
+    "TStoArray",
+    "TStoBatch",
+]
+
+
+class TSCutOff:
+    """Truncates time series data to a specified length for training.
+
+    This class provides a method to truncate or cut off time series data
+    to a specified input length, optionally skipping some initial data
+    points. This is useful for preparing data for training models that
+    require a fixed input size.
+    """
+
+    def __init__(self, size: Dict[str, int]):
+        """Initializes the TSCutOff with size configurations.
+
+        Args:
+            size (Dict[str, int]): Dictionary containing size configurations,
+                including 'in_chunk_len' for the input chunk length and
+                optionally 'skip_chunk_len' for the number of initial data
+                points to skip.
+        """
+        super().__init__()
+        self.size = size
+
+    def __call__(self, ts_list: List) -> List:
+        """Applies the cut off operation to a list of time series.
+
+        Args:
+            ts_list (List): List of time series data frames to be truncated.
+
+        Returns:
+            List: List of truncated time series data frames.
+        """
+        return [self.cutoff(ts) for ts in ts_list]
+
+    def cutoff(self, ts: Any) -> Any:
+        """Truncates a single time series data frame to the specified length.
+
+        This method truncates the time series data to the specified input
+        chunk length, optionally skipping some initial data points. It raises
+        a ValueError if the time series is too short.
+
+        Args:
+            ts: A single time series data frame to be truncated.
+
+        Returns:
+            Any: The truncated time series data frame.
+
+        Raises:
+            ValueError: If the time series length is less than the required
+            minimum length (input chunk length plus any skip chunk length).
+        """
+        skip_len = self.size.get("skip_chunk_len", 0)
+        if len(ts) < self.size["in_chunk_len"] + skip_len:
+            raise ValueError(
+                f"The length of the input data is {len(ts)}, but it should be at least {self.size['in_chunk_len'] + self.size['skip_chunk_len']} for training."
+            )
+        ts_data = ts[-(self.size["in_chunk_len"] + skip_len) :]
+        return ts_data
+
+
+class TSNormalize:
+    """Normalizes time series data using a pre-fitted scaler.
+
+    This class normalizes specified columns of time series data using a
+    pre-fitted scaler loaded from a specified path. It supports normalization
+    of both target and feature columns as specified in the parameters.
+    """
+
+    def __init__(self, scale_path: str, params_info: Dict[str, Any]):
+        """Initializes the TSNormalize with a scaler and normalization parameters.
+
+        Args:
+            scale_path (str): Path to the pre-fitted scaler object file.
+            params_info (Dict[str, Any]): Dictionary containing information
+                about which columns to normalize, including 'target_cols'
+                and 'feature_cols'.
+        """
+        super().__init__()
+        self.scaler = joblib.load(scale_path)
+        self.params_info = params_info
+
+    def __call__(self, ts_list: List[pd.DataFrame]) -> List[pd.DataFrame]:
+        """Applies normalization to a list of time series data frames.
+
+        Args:
+            ts_list (List[pd.DataFrame]): List of time series data frames to be normalized.
+
+        Returns:
+            List[pd.DataFrame]: List of normalized time series data frames.
+        """
+        return [self.tsnorm(ts) for ts in ts_list]
+
+    def tsnorm(self, ts: pd.DataFrame) -> pd.DataFrame:
+        """Normalizes specified columns of a single time series data frame.
+
+        This method applies the scaler to normalize the specified target
+        and feature columns of the time series.
+
+        Args:
+            ts (pd.DataFrame): A single time series data frame to be normalized.
+
+        Returns:
+            pd.DataFrame: The normalized time series data frame.
+        """
+        if self.params_info.get("target_cols", None) is not None:
+            ts[self.params_info["target_cols"]] = self.scaler.transform(
+                ts[self.params_info["target_cols"]]
+            )
+        if self.params_info.get("feature_cols", None) is not None:
+            ts[self.params_info["feature_cols"]] = self.scaler.transform(
+                ts[self.params_info["feature_cols"]]
+            )
+        return ts
+
+
+class BuildTSDataset:
+    """Constructs a time series dataset from a list of time series data frames."""
+
+    def __init__(self, params_info: Dict[str, Any]):
+        """Initializes the BuildTSDataset with parameters for dataset construction.
+
+        Args:
+            params_info (Dict[str, Any]): Dictionary containing parameters for
+                constructing the time series dataset.
+        """
+        super().__init__()
+        self.params_info = params_info
+
+    def __call__(self, ts_list: List) -> List:
+        """Applies the dataset construction to a list of time series.
+
+        Args:
+            ts_list (List): List of time series data frames.
+
+        Returns:
+            List: List of constructed time series datasets.
+        """
+        return [self.buildtsdata(ts) for ts in ts_list]
+
+    def buildtsdata(self, ts) -> Any:
+        """Builds a time series dataset from a single time series data frame.
+
+        Args:
+            ts: A single time series data frame.
+
+        Returns:
+            Any: A constructed time series dataset.
+        """
+        ts_data = load_from_dataframe(ts, **self.params_info)
+        return ts_data
+
+
+class TimeFeature:
+    """Extracts time features from time series data for forecasting."""
+
+    def __init__(
+        self, params_info: Dict[str, Any], size: Dict[str, int], holiday: bool = False
+    ):
+        """Initializes the TimeFeature extractor.
+
+        Args:
+            params_info (Dict[str, Any]): Dictionary containing frequency information.
+            size (Dict[str, int]): Dictionary containing the output chunk length.
+            holiday (bool, optional): Whether to include holiday features. Defaults to False.
+        """
+        super().__init__()
+        self.freq = params_info["freq"]
+        self.size = size
+        self.holiday = holiday
+
+    def __call__(self, ts_list: List) -> List:
+        """Applies time feature extraction to a list of time series.
+
+        Args:
+            ts_list (List): List of time series data frames.
+
+        Returns:
+            List: List of time series with extracted time features.
+        """
+        return [self.timefeat(ts) for ts in ts_list]
+
+    def timefeat(self, ts: Dict[str, Any]) -> Any:
+        """Extracts time features from a single time series data frame.
+
+        Args:
+            ts: A single time series data frame.
+
+        Returns:
+            Any: The time series with added time features.
+        """
+        if not self.holiday:
+            ts = time_feature(
+                ts,
+                self.freq,
+                ["hourofday", "dayofmonth", "dayofweek", "dayofyear"],
+                self.size["out_chunk_len"],
+            )
+        else:
+            ts = time_feature(
+                ts,
+                self.freq,
+                [
+                    "minuteofhour",
+                    "hourofday",
+                    "dayofmonth",
+                    "dayofweek",
+                    "dayofyear",
+                    "monthofyear",
+                    "weekofyear",
+                    "holidays",
+                ],
+                self.size["out_chunk_len"],
+            )
+        return ts
+
+
+class TStoArray:
+    """Converts time series data into arrays for model input."""
+
+    def __init__(self, input_data: Dict[str, Any]):
+        """Initializes the TStoArray converter.
+
+        Args:
+            input_data (Dict[str, Any]): Dictionary specifying the input data format.
+        """
+        super().__init__()
+        self.input_data = input_data
+
+    def __call__(self, ts_list: List[Dict[str, Any]]) -> List[List[np.ndarray]]:
+        """Converts a list of time series data frames into arrays.
+
+        Args:
+            ts_list (List[Dict[str, Any]]): List of time series data frames.
+
+        Returns:
+            List[List[np.ndarray]]: List of lists of arrays for each time series.
+        """
+        return [self.tstoarray(ts) for ts in ts_list]
+
+    def tstoarray(self, ts: Dict[str, Any]) -> List[np.ndarray]:
+        """Converts a single time series data frame into arrays.
+
+        Args:
+            ts (Dict[str, Any]): A single time series data frame.
+
+        Returns:
+            List[np.ndarray]: List of arrays representing the time series data.
+        """
+        ts_list = []
+        input_name = list(self.input_data.keys())
+        input_name.sort()
+        for key in input_name:
+            ts_list.append(np.array(ts[key]).astype("float32"))
+
+        return ts_list
+
+
+class TStoBatch:
+    """Convert a list of time series into batches for processing.
+
+    This class provides a method to convert a list of time series data into
+    batches. Each time series in the list is assumed to be a sequence of
+    equal-length arrays or DataFrames.
+    """
+
+    def __call__(self, ts_list: List[np.ndarray]) -> List[np.ndarray]:
+        """Convert a list of time series into batches.
+
+        This method stacks time series data along a new axis to create batches.
+        It assumes that each time series in the list has the same length.
+
+        Args:
+            ts_list (List[np.ndarray]): A list of time series, where each
+                time series is represented as a list or array of equal length.
+
+        Returns:
+            List[np.ndarray]: A list of batches, where each batch is a stacked
+            array of time series data at the same index across all series.
+        """
+        n = len(ts_list[0])
+        return [np.stack([ts[i] for ts in ts_list], axis=0) for i in range(n)]

paddlex/inference/models/common/vision/__init__.py

@@ -0,0 +1,23 @@
+# 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 . import funcs as F
+from .processors import (
+    Resize,
+    ResizeByLong,
+    ResizeByShort,
+    Normalize,
+    ToCHWImage,
+    ToBatch,
+)

paddlex/inference/models/common/vision/funcs.py

@@ -0,0 +1,93 @@
+# 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 cv2
+import numpy as np
+from PIL import Image
+from .....utils import logging
+
+
+def check_image_size(input_):
+    """check image size"""
+    if not (
+        isinstance(input_, (list, tuple))
+        and len(input_) == 2
+        and isinstance(input_[0], int)
+        and isinstance(input_[1], int)
+    ):
+        raise TypeError(f"{input_} cannot represent a valid image size.")
+
+
+def resize(im, target_size, interp, backend="cv2"):
+    """resize image to target size"""
+    w, h = target_size
+    if backend.lower() == "pil":
+        resize_function = _pil_resize
+    else:
+        resize_function = _cv2_resize
+        if backend.lower() != "cv2":
+            logging.warning(
+                f"Unknown backend {backend}. Defaulting to cv2 for resizing."
+            )
+    im = resize_function(im, (w, h), interp)
+    return im
+
+
+def _cv2_resize(src, size, resample):
+    return cv2.resize(src, size, interpolation=resample)
+
+
+def _pil_resize(src, size, resample):
+    if isinstance(src, np.ndarray):
+        pil_img = Image.fromarray(src)
+    else:
+        pil_img = src
+    pil_img = pil_img.resize(size, resample)
+    return np.asarray(pil_img)
+
+
+def flip_h(im):
+    """flip image horizontally"""
+    if len(im.shape) == 3:
+        im = im[:, ::-1, :]
+    elif len(im.shape) == 2:
+        im = im[:, ::-1]
+    return im
+
+
+def flip_v(im):
+    """flip image vertically"""
+    if len(im.shape) == 3:
+        im = im[::-1, :, :]
+    elif len(im.shape) == 2:
+        im = im[::-1, :]
+    return im
+
+
+def slice(im, coords):
+    """slice the image"""
+    x1, y1, x2, y2 = coords
+    im = im[y1:y2, x1:x2, ...]
+    return im
+
+
+def pad(im, pad, val):
+    """padding image by value"""
+    if isinstance(pad, int):
+        pad = [pad] * 4
+    if len(pad) != 4:
+        raise ValueError
+    chns = 1 if im.ndim == 2 else im.shape[2]
+    im = cv2.copyMakeBorder(im, *pad, cv2.BORDER_CONSTANT, value=(val,) * chns)
+    return im

paddlex/inference/models/common/vision/processors.py

@@ -0,0 +1,270 @@
+# 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 ast
+import math
+from pathlib import Path
+from copy import deepcopy
+
+import numpy as np
+import cv2
+from PIL import Image
+
+from . import funcs as F
+
+
+class _BaseResize:
+    _CV2_INTERP_DICT = {
+        "NEAREST": cv2.INTER_NEAREST,
+        "LINEAR": cv2.INTER_LINEAR,
+        "BICUBIC": cv2.INTER_CUBIC,
+        "AREA": cv2.INTER_AREA,
+        "LANCZOS4": cv2.INTER_LANCZOS4,
+    }
+    _PIL_INTERP_DICT = {
+        "NEAREST": Image.NEAREST,
+        "BILINEAR": Image.BILINEAR,
+        "BICUBIC": Image.BICUBIC,
+        "BOX": Image.BOX,
+        "LANCZOS4": Image.LANCZOS,
+    }
+
+    def __init__(self, size_divisor, interp, backend="cv2"):
+        super().__init__()
+
+        if size_divisor is not None:
+            assert isinstance(
+                size_divisor, int
+            ), "`size_divisor` should be None or int."
+        self.size_divisor = size_divisor
+
+        try:
+            interp = interp.upper()
+            if backend == "cv2":
+                interp = self._CV2_INTERP_DICT[interp]
+            elif backend == "pil":
+                interp = self._PIL_INTERP_DICT[interp]
+            else:
+                raise ValueError("backend must be `cv2` or `pil`")
+        except KeyError:
+            raise ValueError(
+                "For backend '{}', `interp` should be one of {}. Please ensure the interpolation method matches the selected backend.".format(
+                    backend,
+                    (
+                        self._CV2_INTERP_DICT.keys()
+                        if backend == "cv2"
+                        else self._PIL_INTERP_DICT.keys()
+                    ),
+                )
+            )
+        self.interp = interp
+        self.backend = backend
+
+    @staticmethod
+    def _rescale_size(img_size, target_size):
+        """rescale size"""
+        scale = min(max(target_size) / max(img_size), min(target_size) / min(img_size))
+        rescaled_size = [round(i * scale) for i in img_size]
+        return rescaled_size, scale
+
+
+class Resize(_BaseResize):
+    """Resize the image."""
+
+    def __init__(
+        self,
+        target_size,
+        keep_ratio=False,
+        size_divisor=None,
+        interp="LINEAR",
+        backend="cv2",
+    ):
+        """
+        Initialize the instance.
+
+        Args:
+            target_size (list|tuple|int): Target width and height.
+            keep_ratio (bool, optional): Whether to keep the aspect ratio of resized
+                image. Default: False.
+            size_divisor (int|None, optional): Divisor of resized image size.
+                Default: None.
+            interp (str, optional): Interpolation method. Choices are 'NEAREST',
+                'LINEAR', 'CUBIC', 'AREA', and 'LANCZOS4'. Default: 'LINEAR'.
+        """
+        super().__init__(size_divisor=size_divisor, interp=interp, backend=backend)
+
+        if isinstance(target_size, int):
+            target_size = [target_size, target_size]
+        F.check_image_size(target_size)
+        self.target_size = target_size
+
+        self.keep_ratio = keep_ratio
+
+    def __call__(self, imgs):
+        """apply"""
+        return [self.resize(img) for img in imgs]
+
+    def resize(self, img):
+        target_size = self.target_size
+        original_size = img.shape[:2][::-1]
+
+        if self.keep_ratio:
+            h, w = img.shape[0:2]
+            target_size, _ = self._rescale_size((w, h), self.target_size)
+
+        if self.size_divisor:
+            target_size = [
+                math.ceil(i / self.size_divisor) * self.size_divisor
+                for i in target_size
+            ]
+        img = F.resize(img, target_size, interp=self.interp, backend=self.backend)
+        return img
+
+
+class ResizeByLong(_BaseResize):
+    """
+    Proportionally resize the image by specifying the target length of the
+    longest side.
+    """
+
+    def __init__(
+        self, target_long_edge, size_divisor=None, interp="LINEAR", backend="cv2"
+    ):
+        """
+        Initialize the instance.
+
+        Args:
+            target_long_edge (int): Target length of the longest side of image.
+            size_divisor (int|None, optional): Divisor of resized image size.
+                Default: None.
+            interp (str, optional): Interpolation method. Choices are 'NEAREST',
+                'LINEAR', 'CUBIC', 'AREA', and 'LANCZOS4'. Default: 'LINEAR'.
+        """
+        super().__init__(size_divisor=size_divisor, interp=interp, backend=backend)
+        self.target_long_edge = target_long_edge
+
+    def __call__(self, imgs):
+        """apply"""
+        return [self.resize(img) for img in imgs]
+
+    def resize(self, img):
+        h, w = img.shape[:2]
+        scale = self.target_long_edge / max(h, w)
+        h_resize = round(h * scale)
+        w_resize = round(w * scale)
+        if self.size_divisor is not None:
+            h_resize = math.ceil(h_resize / self.size_divisor) * self.size_divisor
+            w_resize = math.ceil(w_resize / self.size_divisor) * self.size_divisor
+
+        img = F.resize(
+            img, (w_resize, h_resize), interp=self.interp, backend=self.backend
+        )
+        return img
+
+
+class ResizeByShort(_BaseResize):
+    """
+    Proportionally resize the image by specifying the target length of the
+    shortest side.
+    """
+
+    def __init__(
+        self, target_short_edge, size_divisor=None, interp="LINEAR", backend="cv2"
+    ):
+        """
+        Initialize the instance.
+
+        Args:
+            target_short_edge (int): Target length of the shortest side of image.
+            size_divisor (int|None, optional): Divisor of resized image size.
+                Default: None.
+            interp (str, optional): Interpolation method. Choices are 'NEAREST',
+                'LINEAR', 'CUBIC', 'AREA', and 'LANCZOS4'. Default: 'LINEAR'.
+        """
+        super().__init__(size_divisor=size_divisor, interp=interp, backend=backend)
+        self.target_short_edge = target_short_edge
+
+    def __call__(self, imgs):
+        """apply"""
+        return [self.resize(img) for img in imgs]
+
+    def resize(self, img):
+        h, w = img.shape[:2]
+        scale = self.target_short_edge / min(h, w)
+        h_resize = round(h * scale)
+        w_resize = round(w * scale)
+        if self.size_divisor is not None:
+            h_resize = math.ceil(h_resize / self.size_divisor) * self.size_divisor
+            w_resize = math.ceil(w_resize / self.size_divisor) * self.size_divisor
+
+        img = F.resize(
+            img, (w_resize, h_resize), interp=self.interp, backend=self.backend
+        )
+        return img
+
+
+class Normalize:
+    """Normalize the image."""
+
+    def __init__(self, scale=1.0 / 255, mean=0.5, std=0.5, preserve_dtype=False):
+        """
+        Initialize the instance.
+
+        Args:
+            scale (float, optional): Scaling factor to apply to the image before
+                applying normalization. Default: 1/255.
+            mean (float|tuple|list, optional): Means for each channel of the image.
+                Default: 0.5.
+            std (float|tuple|list, optional): Standard deviations for each channel
+                of the image. Default: 0.5.
+            preserve_dtype (bool, optional): Whether to preserve the original dtype
+                of the image.
+        """
+        super().__init__()
+
+        self.scale = np.float32(scale)
+        if isinstance(mean, float):
+            mean = [mean]
+        self.mean = np.asarray(mean).astype("float32")
+        if isinstance(std, float):
+            std = [std]
+        self.std = np.asarray(std).astype("float32")
+        self.preserve_dtype = preserve_dtype
+
+    def __call__(self, imgs):
+        """apply"""
+        old_type = imgs[0].dtype
+        # XXX: If `old_type` has higher precision than float32,
+        # we will lose some precision.
+        imgs = np.array(imgs).astype("float32", copy=False)
+        imgs *= self.scale
+        imgs -= self.mean
+        imgs /= self.std
+        if self.preserve_dtype:
+            imgs = imgs.astype(old_type, copy=False)
+        return list(imgs)
+
+
+class ToCHWImage:
+    """Reorder the dimensions of the image from HWC to CHW."""
+
+    def __call__(self, imgs):
+        """apply"""
+        return [img.transpose((2, 0, 1)) for img in imgs]
+
+
+class ToBatch:
+    def __call__(self, imgs):
+        return [np.stack(imgs, axis=0).astype(dtype=np.float32, copy=False)]