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

paddlex/inference/models/common/tokenizer/utils.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

paddlex/inference/models/common/tokenizer/vocab.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

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

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

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

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -13,15 +13,19 @@
 # limitations under the License.
 
 
-from typing import Any, Callable, List, Optional, Sequence, Tuple, Union, Dict
-import os
+from typing import Callable, Dict, List, Optional, Union
+
 import numpy as np
 import pandas as pd
-import chinese_calendar
-from pandas.tseries.offsets import DateOffset, Easter, Day
 from pandas.tseries import holiday as hd
-from sklearn.preprocessing import StandardScaler
+from pandas.tseries.offsets import DateOffset, Day, Easter
+
+from .....utils.deps import function_requires_deps, is_dep_available
 
+if is_dep_available("chinese-calendar"):
+    import chinese_calendar
+if is_dep_available("scikit-learn"):
+    from sklearn.preprocessing import StandardScaler
 
 MAX_WINDOW = 183 + 17
 EasterSunday = hd.Holiday("Easter Sunday", month=1, day=1, offset=[Easter(), Day(0)])
@@ -135,12 +139,14 @@ def _cal_weekofyear(
     return x.weekofyear / 51.0 - 0.5
 
 
+@function_requires_deps("chinese-calendar")
 def _cal_holiday(
     x: np.datetime64,
 ):
     return float(chinese_calendar.is_holiday(x))
 
 
+@function_requires_deps("chinese-calendar")
 def _cal_workday(
     x: np.datetime64,
 ):
@@ -444,6 +450,7 @@ def _distance_to_holiday(holiday) -> Callable[[pd.Timestamp], float]:
     return _distance_to_day
 
 
+@function_requires_deps("scikit-learn")
 def time_feature(
     dataset: Dict,
     freq: Optional[Union[str, int]],

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

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,15 +12,17 @@
 # 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
+from typing import Any, Dict, List
+
 import numpy as np
 import pandas as pd
 
+from .....utils.deps import class_requires_deps, is_dep_available
+from ....utils.benchmark import benchmark
 from .funcs import load_from_dataframe, time_feature
 
+if is_dep_available("joblib"):
+    import joblib
 
 __all__ = [
     "BuildTSDataset",
@@ -32,6 +34,7 @@ __all__ = [
 ]
 
 
+@benchmark.timeit
 class TSCutOff:
     """Truncates time series data to a specified length for training.
 
@@ -90,6 +93,8 @@ class TSCutOff:
         return ts_data
 
 
+@benchmark.timeit
+@class_requires_deps("joblib")
 class TSNormalize:
     """Normalizes time series data using a pre-fitted scaler.
 
@@ -145,6 +150,7 @@ class TSNormalize:
         return ts
 
 
+@benchmark.timeit
 class BuildTSDataset:
     """Constructs a time series dataset from a list of time series data frames."""
 
@@ -182,6 +188,7 @@ class BuildTSDataset:
         return ts_data
 
 
+@benchmark.timeit
 class TimeFeature:
     """Extracts time features from time series data for forecasting."""
 
@@ -246,6 +253,7 @@ class TimeFeature:
         return ts
 
 
+@benchmark.timeit
 class TStoArray:
     """Converts time series data into arrays for model input."""
 
@@ -287,6 +295,7 @@ class TStoArray:
         return ts_list
 
 
+@benchmark.timeit
 class TStoBatch:
     """Convert a list of time series into batches for processing.
 

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

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -14,10 +14,10 @@
 
 from . import funcs as F
 from .processors import (
+    Normalize,
     Resize,
     ResizeByLong,
     ResizeByShort,
-    Normalize,
-    ToCHWImage,
     ToBatch,
+    ToCHWImage,
 )

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

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,10 +12,14 @@
 # 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
+from .....utils.deps import function_requires_deps, is_dep_available
+
+if is_dep_available("opencv-contrib-python"):
+    import cv2
 
 
 def check_image_size(input_):
@@ -32,6 +36,8 @@ def check_image_size(input_):
 def resize(im, target_size, interp, backend="cv2"):
     """resize image to target size"""
     w, h = target_size
+    if w == im.shape[1] and h == im.shape[0]:
+        return im
     if backend.lower() == "pil":
         resize_function = _pil_resize
     else:
@@ -44,6 +50,7 @@ def resize(im, target_size, interp, backend="cv2"):
     return im
 
 
+@function_requires_deps("opencv-contrib-python")
 def _cv2_resize(src, size, resample):
     return cv2.resize(src, size, interpolation=resample)
 
@@ -57,22 +64,16 @@ def _pil_resize(src, size, resample):
     return np.asarray(pil_img)
 
 
+@function_requires_deps("opencv-contrib-python")
 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
+    return cv2.flip(im, 1)
 
 
+@function_requires_deps("opencv-contrib-python")
 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
+    return cv2.flip(im, 0)
 
 
 def slice(im, coords):
@@ -82,12 +83,16 @@ def slice(im, coords):
     return im
 
 
+@function_requires_deps("opencv-contrib-python")
 def pad(im, pad, val):
     """padding image by value"""
     if isinstance(pad, int):
         pad = [pad] * 4
     if len(pad) != 4:
         raise ValueError
+    if all(x == 0 for x in pad):
+        return im
+
     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

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,36 +12,37 @@
 # 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 .....utils.deps import class_requires_deps, is_dep_available
+from ....utils.benchmark import benchmark
 from . import funcs as F
 
+if is_dep_available("opencv-contrib-python"):
+    import cv2
 
-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,
-    }
 
+@class_requires_deps("opencv-contrib-python")
+class _BaseResize:
     def __init__(self, size_divisor, interp, backend="cv2"):
+        _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,
+        }
+
         super().__init__()
 
         if size_divisor is not None:
@@ -53,9 +54,9 @@ class _BaseResize:
         try:
             interp = interp.upper()
             if backend == "cv2":
-                interp = self._CV2_INTERP_DICT[interp]
+                interp = _CV2_INTERP_DICT[interp]
             elif backend == "pil":
-                interp = self._PIL_INTERP_DICT[interp]
+                interp = _PIL_INTERP_DICT[interp]
             else:
                 raise ValueError("backend must be `cv2` or `pil`")
         except KeyError:
@@ -63,9 +64,9 @@ class _BaseResize:
                 "For backend '{}', `interp` should be one of {}. Please ensure the interpolation method matches the selected backend.".format(
                     backend,
                     (
-                        self._CV2_INTERP_DICT.keys()
+                        _CV2_INTERP_DICT.keys()
                         if backend == "cv2"
-                        else self._PIL_INTERP_DICT.keys()
+                        else _PIL_INTERP_DICT.keys()
                     ),
                 )
             )
@@ -80,6 +81,7 @@ class _BaseResize:
         return rescaled_size, scale
 
 
+@benchmark.timeit
 class Resize(_BaseResize):
     """Resize the image."""
 
@@ -133,6 +135,7 @@ class Resize(_BaseResize):
         return img
 
 
+@benchmark.timeit
 class ResizeByLong(_BaseResize):
     """
     Proportionally resize the image by specifying the target length of the
@@ -174,6 +177,7 @@ class ResizeByLong(_BaseResize):
         return img
 
 
+@benchmark.timeit
 class ResizeByShort(_BaseResize):
     """
     Proportionally resize the image by specifying the target length of the
@@ -215,10 +219,12 @@ class ResizeByShort(_BaseResize):
         return img
 
 
+@benchmark.timeit
+@class_requires_deps("opencv-contrib-python")
 class Normalize:
-    """Normalize the image."""
+    """Normalize the three-channel image."""
 
-    def __init__(self, scale=1.0 / 255, mean=0.5, std=0.5, preserve_dtype=False):
+    def __init__(self, scale=1.0 / 255, mean=0.5, std=0.5):
         """
         Initialize the instance.
 
@@ -227,36 +233,44 @@ class Normalize:
                 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
+            std (float|tuple|list|np.ndarray, 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")
+            mean = [mean] * 3
+        elif len(mean) != 3:
+            raise ValueError(
+                f"Expected `mean` to be a tuple or list of length 3, but got {len(mean)} elements."
+            )
         if isinstance(std, float):
-            std = [std]
-        self.std = np.asarray(std).astype("float32")
-        self.preserve_dtype = preserve_dtype
+            std = [std] * 3
+        elif len(std) != 3:
+            raise ValueError(
+                f"Expected `std` to be a tuple or list of length 3, but got {len(std)} elements."
+            )
+
+        self.alpha = [scale / std[i] for i in range(len(std))]
+        self.beta = [-mean[i] / std[i] for i in range(len(std))]
+
+    def norm(self, img):
+        split_im = list(cv2.split(img))
+
+        for c in range(img.shape[2]):
+            split_im[c] = split_im[c].astype(np.float32)
+            split_im[c] *= self.alpha[c]
+            split_im[c] += self.beta[c]
+
+        res = cv2.merge(split_im)
+        return res
 
     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)
+        return [self.norm(img) for img in imgs]
 
 
+@benchmark.timeit
 class ToCHWImage:
     """Reorder the dimensions of the image from HWC to CHW."""
 
@@ -265,6 +279,7 @@ class ToCHWImage:
         return [img.transpose((2, 0, 1)) for img in imgs]
 
 
+@benchmark.timeit
 class ToBatch:
     def __call__(self, imgs):
         return [np.stack(imgs, axis=0).astype(dtype=np.float32, copy=False)]

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

@@ -0,0 +1,13 @@
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+#
+# 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.

paddlex/inference/models/common/vlm/activations.py

@@ -0,0 +1,189 @@
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+#
+# 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 math
+from collections import OrderedDict
+
+import paddle
+import paddle.nn.functional as F
+from paddle import Tensor, nn
+
+
+class NewGELUActivation(nn.Layer):
+    """
+    Implementation of the GELU activation function currently in Google BERT repo (identical to OpenAI GPT). Also see
+    the Gaussian Error Linear Units paper: https://arxiv.org/abs/1606.08415
+    """
+
+    def forward(self, input: Tensor) -> Tensor:
+        return (
+            0.5
+            * input
+            * (
+                1.0
+                + paddle.tanh(
+                    math.sqrt(2.0 / math.pi)
+                    * (input + 0.044715 * paddle.pow(input, 3.0))
+                )
+            )
+        )
+
+
+class GELUActivation(nn.Layer):
+    """
+    Original Implementation of the GELU activation function in Google BERT repo when initially created. For
+    information: OpenAI GPT's GELU is slightly different (and gives slightly different results): 0.5 * x * (1 +
+    torch.tanh(math.sqrt(2 / math.pi) * (x + 0.044715 * torch.pow(x, 3)))) This is now written in C in nn.functional
+    Also see the Gaussian Error Linear Units paper: https://arxiv.org/abs/1606.08415
+    """
+
+    def __init__(self, use_gelu_python: bool = False):
+        super().__init__()
+        if use_gelu_python:
+            self.act = self._gelu_python
+        else:
+            self.act = nn.functional.gelu
+
+    def _gelu_python(self, input: Tensor) -> Tensor:
+        return input * 0.5 * (1.0 + paddle.erf(input / math.sqrt(2.0)))
+
+    def forward(self, input: Tensor) -> Tensor:
+        return self.act(input)
+
+
+class FastGELUActivation(nn.Layer):
+    """
+    Applies GELU approximation that is slower than QuickGELU but more accurate. See: https://github.com/hendrycks/GELUs
+    """
+
+    def forward(self, input: Tensor) -> Tensor:
+        return (
+            0.5
+            * input
+            * (
+                1.0
+                + paddle.tanh(input * 0.7978845608 * (1.0 + 0.044715 * input * input))
+            )
+        )
+
+
+class QuickGELUActivation(nn.Layer):
+    """
+    Applies GELU approximation that is fast but somewhat inaccurate. See: https://github.com/hendrycks/GELUs
+    """
+
+    def forward(self, input: Tensor) -> Tensor:
+        return input * F.sigmoid(1.702 * input)
+
+
+class ClippedGELUActivation(nn.Layer):
+    """
+    Clip the range of possible GeLU outputs between [min, max]. This is especially useful for quantization purpose, as
+    it allows mapping negatives values in the GeLU spectrum. For more information on this trick, please refer to
+    https://arxiv.org/abs/2004.09602.
+
+    Gaussian Error Linear Unit. Original Implementation of the gelu activation function in Google Bert repo when
+    initially created.
+
+    For information: OpenAI GPT's gelu is slightly different (and gives slightly different results): 0.5 * x * (1 +
+    torch.tanh(math.sqrt(2 / math.pi) * (x + 0.044715 * torch.pow(x, 3)))). See https://arxiv.org/abs/1606.08415
+    """
+
+    def __init__(self, min: float, max: float):
+        if min > max:
+            raise ValueError(f"min should be < max (got min: {min}, max: {max})")
+
+        super().__init__()
+        self.min = min
+        self.max = max
+
+    def forward(self, x: Tensor) -> Tensor:
+        return paddle.clip(gelu(x), self.min, self.max)
+
+
+class SiLUActivation(nn.Layer):
+    """
+    See Gaussian Error Linear Units (Hendrycks et al., https://arxiv.org/abs/1606.08415) where the SiLU (Sigmoid Linear
+    Unit) was originally introduced and coined, and see Sigmoid-Weighted Linear Units for Neural Network Function
+    Approximation in Reinforcement Learning (Elfwing et al., https://arxiv.org/abs/1702.03118) and Swish: a Self-Gated
+    Activation Function (Ramachandran et al., https://arxiv.org/abs/1710.05941v1) where the SiLU was experimented with
+    later.
+    """
+
+    def forward(self, input: Tensor) -> Tensor:
+        return F.silu(input)
+
+
+class MishActivation(nn.Layer):
+    """
+    See Mish: A Self-Regularized Non-Monotonic Activation Function (Misra., https://arxiv.org/abs/1908.08681). Also
+    visit the official repository for the paper: https://github.com/digantamisra98/Mish
+    """
+
+    def forward(self, input: Tensor) -> Tensor:
+        return F.mish(input)
+
+
+class LinearActivation(nn.Layer):
+    """
+    Applies the linear activation function, i.e. forwarding input directly to output.
+    """
+
+    def forward(self, input: Tensor) -> Tensor:
+        return input
+
+
+class ClassInstantier(OrderedDict):
+    def __getitem__(self, key):
+        content = super().__getitem__(key)
+        cls, kwargs = content if isinstance(content, tuple) else (content, {})
+        return cls(**kwargs)
+
+
+ACT2CLS = {
+    "gelu": GELUActivation,
+    "gelu_10": (ClippedGELUActivation, {"min": -10, "max": 10}),
+    "gelu_fast": FastGELUActivation,
+    "gelu_new": NewGELUActivation,
+    "gelu_python": (GELUActivation, {"use_gelu_python": True}),
+    "linear": LinearActivation,
+    "mish": MishActivation,
+    "quick_gelu": QuickGELUActivation,
+    "relu": nn.ReLU,
+    "relu6": nn.ReLU6,
+    "sigmoid": nn.Sigmoid,
+    "silu": SiLUActivation,
+    "swish": SiLUActivation,
+    "tanh": nn.Tanh,
+}
+ACT2FN = ClassInstantier(ACT2CLS)
+
+
+def get_activation(activation_string):
+    if activation_string in ACT2FN:
+        return ACT2FN[activation_string]
+    else:
+        raise KeyError(
+            f"function {activation_string} not found in ACT2FN mapping {list(ACT2FN.keys())}"
+        )
+
+
+gelu_python = get_activation("gelu_python")
+gelu_new = get_activation("gelu_new")
+gelu = get_activation("gelu")
+gelu_fast = get_activation("gelu_fast")
+quick_gelu = get_activation("quick_gelu")
+silu = get_activation("silu")
+mish = get_activation("mish")
+linear_act = get_activation("linear")