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

paddlex/inference/models/ts_anomaly_detection/result.py

@@ -0,0 +1,72 @@
+# 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 Any
+import io
+import pandas as pd
+import matplotlib.pyplot as plt
+from PIL import Image
+
+from ...common.result import BaseTSResult
+
+
+def visualize(forecast: pd.DataFrame) -> Image.Image:
+    """
+    Visualizes both the time series forecast and actual results, returning them as a Pillow image.
+
+    Args:
+        forecast (pd.DataFrame): The DataFrame containing the forecast data.
+
+    Returns:
+        Image.Image: The visualized result as a Pillow image.
+    """
+    plt.figure(figsize=(12, 6))
+    forecast_columns = forecast.columns
+    index_name = forecast.index.name
+    forecast.index = forecast.index.astype(str)
+
+    plt.step(forecast.index, forecast[forecast_columns[0]], where='post', label='Anomaly', color='red')
+    plt.title('Time Series Anomaly Detection')
+    plt.xlabel('Time')
+    plt.ylabel(forecast_columns[0])
+    plt.legend()
+    plt.grid(True)
+    plt.xticks(ticks=range(0, len(forecast), 10))
+    plt.xticks(rotation=45)
+
+    buf = io.BytesIO()
+    plt.savefig(buf, bbox_inches='tight')
+    buf.seek(0)
+    plt.close()
+    image = Image.open(buf)
+
+    return image
+
+
+class TSAdResult(BaseTSResult):
+    """A class representing the result of a time series anomaly detection task."""
+
+    def _to_img(self) -> Image.Image:
+        """apply"""
+        anomaly = self["anomaly"]
+        return {"res": visualize(anomaly)}
+    
+    def _to_csv(self) -> Any:
+        """
+        Converts the anomaly detection results to a CSV format.
+
+        Returns:
+            Any: The anomaly data formatted for CSV output, typically a DataFrame or similar structure.
+        """
+        return {"res": self["anomaly"]}

paddlex/inference/models/ts_classification/__init__.py

@@ -0,0 +1,15 @@
+# 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 .predictor import TSClsPredictor

paddlex/inference/models/ts_classification/predictor.py

@@ -0,0 +1,135 @@
+# 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 Any, Union, Dict, List, Tuple
+import numpy as np
+import pandas as pd
+import os
+import copy
+
+from ....modules.ts_classification.model_list import MODELS
+from ...common.batch_sampler import TSBatchSampler
+from ...common.reader import ReadTS
+from ..common import (
+    TSCutOff,
+    BuildTSDataset,
+    TSNormalize,
+    TimeFeature,
+    TStoArray,
+    TStoBatch,
+    StaticInfer,
+)
+
+from .processors import GetCls, BuildPadMask
+from ..base import BasicPredictor
+from .result import TSClsResult
+
+
+class TSClsPredictor(BasicPredictor):
+    """TSClsPredictor that inherits from BasicPredictor."""
+
+    entities = MODELS
+
+    def __init__(self, *args: List, **kwargs: Dict) -> None:
+        """Initializes TSClsPredictor.
+
+        Args:
+            *args: Arbitrary positional arguments passed to the superclass.
+            **kwargs: Arbitrary keyword arguments passed to the superclass.
+        """
+        super().__init__(*args, **kwargs)
+        self.preprocessors, self.infer, self.postprocessors = self._build()
+
+    def _build_batch_sampler(self) -> TSBatchSampler:
+        """Builds and returns an TSBatchSampler instance.
+
+        Returns:
+            TSBatchSampler: An instance of TSBatchSampler.
+        """
+        return TSBatchSampler()
+
+    def _get_result_class(self) -> type:
+        """Returns the result class.
+
+        Returns:
+            type: The Result class.
+        """
+        return TSClsResult
+
+    def _build(self) -> Tuple:
+        """Build the preprocessors, inference engine, and postprocessors based on the configuration.
+
+        Returns:
+            tuple: A tuple containing the preprocessors, inference engine, and postprocessors.
+        """
+        preprocessors = {
+            "ReadTS": ReadTS(),
+            "TSCutOff": TSCutOff(self.config["size"]),
+        }
+
+        if self.config.get("scale", None):
+            scaler_file_path = os.path.join(self.model_dir, "scaler.pkl")
+            if not os.path.exists(scaler_file_path):
+                raise Exception(f"Cannot find scaler file: {scaler_file_path}")
+            preprocessors["TSNormalize"] = TSNormalize(
+                scaler_file_path, self.config["info_params"]
+            )
+
+        preprocessors["BuildTSDataset"] = BuildTSDataset(self.config["info_params"])
+        preprocessors["BuildPadMask"] = BuildPadMask(self.config["input_data"])
+        preprocessors["TStoArray"] = TStoArray(self.config["input_data"])
+        preprocessors["TStoBatch"] = TStoBatch()
+        infer = StaticInfer(
+            model_dir=self.model_dir,
+            model_prefix=self.MODEL_FILE_PREFIX,
+            option=self.pp_option,
+        )
+        postprocessors = {}
+        postprocessors["GetCls"] = GetCls()
+        return preprocessors, infer, postprocessors
+
+    def process(self, batch_data: List[Union[str, pd.DataFrame]]) -> Dict[str, Any]:
+        """
+        Processes a batch of time series data through a series of preprocessing, inference, and postprocessing steps.
+
+        Args:
+            batch_data (List[Union[str, pd.DataFrame]]): A list of paths or identifiers for the batch of time series data to be processed.
+
+        Returns:
+            Dict[str, Any]: A dictionary containing the paths to the input data, the raw input time series, and the classification results.
+        """
+        batch_raw_ts = self.preprocessors["ReadTS"](ts_list=batch_data)
+        batch_raw_ts_ori = copy.deepcopy(batch_raw_ts)
+
+        if "TSNormalize" in self.preprocessors:
+            batch_ts = self.preprocessors["TSNormalize"](ts_list=batch_raw_ts)
+            batch_input_ts = self.preprocessors["BuildTSDataset"](ts_list=batch_ts)
+        else:
+            batch_input_ts = self.preprocessors["BuildTSDataset"](ts_list=batch_raw_ts)
+
+        batch_input_ts = self.preprocessors["BuildPadMask"](ts_list=batch_input_ts)
+        batch_ts = self.preprocessors["TStoArray"](ts_list=batch_input_ts)
+
+        x = self.preprocessors["TStoBatch"](ts_list=batch_ts)
+        batch_preds = self.infer(x=x)
+
+        batch_ts_preds = self.postprocessors["GetCls"](pred_list=batch_preds)
+
+        return {
+            "input_path": batch_data,
+            "input_ts": batch_raw_ts,
+            "input_ts_data": batch_raw_ts_ori,
+            "classification": batch_ts_preds,
+            "target_cols": [self.config["info_params"]["target_cols"]]
+        }

paddlex/inference/models/ts_classification/processors.py

@@ -0,0 +1,117 @@
+# 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 numpy as np
+import pandas as pd
+from typing import List, Any, Dict
+
+
+class GetCls:
+    """A class to process prediction outputs and return class IDs and scores."""
+
+    def __init__(self):
+        """Initializes the GetCls instance."""
+        super().__init__()
+
+    def __call__(self, pred_list: List[Any]) -> List[pd.DataFrame]:
+        """
+        Processes a list of predictions and returns a list of DataFrames with class IDs and scores.
+
+        Args:
+            pred_list (List[Any]): A list of predictions, where each prediction is expected to be an iterable of arrays.
+
+        Returns:
+            List[pd.DataFrame]: A list of DataFrames, each containing the class ID and score for the corresponding prediction.
+        """
+        return [self.getcls(pred) for pred in pred_list]
+
+    def getcls(self, pred: Any) -> pd.DataFrame:
+        """
+        Computes the class ID and score from a single prediction.
+
+        Args:
+            pred (Any): A prediction, expected to be an iterable where the first element is an array representing logits or probabilities.
+
+        Returns:
+            pd.DataFrame: A DataFrame containing the class ID and score for the prediction.
+        """
+        pred_ts = pred[0]
+        pred_ts -= np.max(pred_ts, axis=-1, keepdims=True)
+        pred_ts = np.exp(pred_ts) / np.sum(np.exp(pred_ts), axis=-1, keepdims=True)
+        classid = np.argmax(pred_ts, axis=-1)
+        pred_score = pred_ts[classid]
+        result = pd.DataFrame.from_dict({"classid": [classid], "score": [pred_score]})
+        result.index.name = "sample"
+        return result
+
+
+class BuildPadMask:
+    """A class to build padding masks for time series data."""
+
+    def __init__(self, input_data: Dict[str, Any]):
+        """
+        Initializes the BuildPadMask instance.
+
+        Args:
+            input_data (Dict[str, Any]): A dictionary containing configuration data, including 'features'
+                                         and 'pad_mask' keys that influence how padding is applied.
+        """
+        super().__init__()
+        self.input_data = input_data
+
+    def __call__(self, ts_list: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """
+        Applies padding mask to a list of time series data.
+
+        Args:
+            ts_list (List[Dict[str, Any]]): A list of dictionaries, each representing a time series instance
+                                            with keys like 'features' and 'past_target'.
+
+        Returns:
+            List[Dict[str, Any]]: A list of dictionaries with updated 'features' and 'pad_mask' keys.
+        """
+        return [self.padmask(ts) for ts in ts_list]
+
+    def padmask(self, ts: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Builds a padding mask for a single time series instance.
+
+        Args:
+            ts (Dict[str, Any]): A dictionary representing a time series instance, expected to have keys
+                                 like 'features' and 'past_target'.
+
+        Returns:
+            Dict[str, Any]: The input dictionary with potentially updated 'features' and 'pad_mask' keys.
+        """
+        if "features" in self.input_data:
+            ts["features"] = ts["past_target"]
+
+        if "pad_mask" in self.input_data:
+            target_dim = len(ts["features"])
+            max_length = self.input_data["pad_mask"][-1]
+            if max_length > 0:
+                ones = np.ones(max_length, dtype=np.int32)
+                if max_length != target_dim:
+                    target_ndarray = np.array(ts["features"]).astype(np.float32)
+                    target_ndarray_final = np.zeros(
+                        [max_length, target_dim], dtype=np.int32
+                    )
+                    end = min(target_dim, max_length)
+                    target_ndarray_final[:end, :] = target_ndarray
+                    ts["features"] = target_ndarray_final
+                    ones[end:] = 0.0
+                    ts["pad_mask"] = ones
+                else:
+                    ts["pad_mask"] = ones
+        return ts

paddlex/inference/models/ts_classification/result.py

@@ -0,0 +1,78 @@
+# 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 Any
+import io
+import pandas as pd
+import matplotlib.pyplot as plt
+from PIL import Image
+
+from ...common.result import BaseTSResult
+
+
+def visualize(predicted_label, input_ts, target_cols):
+    """
+    Visualize time series data and its prediction results.
+
+    Parameters:
+    - input_ts: A DataFrame containing the input_ts.
+    - predicted_label: A list of predicted class labels.
+
+    Returns:
+    - image: An image object containing the visualization result.
+    """
+    # 设置图形大小
+    plt.figure(figsize=(12, 6))
+    input_ts_columns = input_ts.columns
+    input_ts.index = input_ts.index.astype(str)
+    length = len(input_ts)
+    value = predicted_label.loc[0, 'classid']
+    plt.plot(input_ts.index, input_ts[target_cols[0]], label=f'Predicted classid: {value}', color='blue')
+
+    # 设置图形标题和标签
+    plt.title('Time Series input_ts with Predicted Labels')
+    plt.xlabel('Time')
+    plt.ylabel('Value')
+    plt.legend()
+    plt.grid(True)
+    plt.xticks(ticks=range(0, length, 10))
+    plt.xticks(rotation=45)
+
+    # 保存图像到内存
+    buf = io.BytesIO()
+    plt.savefig(buf, bbox_inches='tight')
+    buf.seek(0)
+    plt.close()
+    image = Image.open(buf)
+
+    return image
+
+
+class TSClsResult(BaseTSResult):
+    """A class representing the result of a time series classification task."""
+
+    def _to_img(self) -> Image.Image:
+        """apply"""
+        classification = self["classification"]
+        ts_input = self["input_ts_data"]
+        return {"res": visualize(classification, ts_input, self["target_cols"])}
+    
+    def _to_csv(self) -> Any:
+        """
+        Converts the classification results to a CSV format.
+
+        Returns:
+            Any: The classification data formatted for CSV output, typically a DataFrame or similar structure.
+        """
+        return {"res": self["classification"]}

paddlex/inference/models/ts_forecasting/__init__.py

@@ -0,0 +1,15 @@
+# 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 .predictor import TSFcPredictor

paddlex/inference/models/ts_forecasting/predictor.py

@@ -0,0 +1,159 @@
+# 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 Any, Union, Dict, List, Tuple
+import numpy as np
+import pandas as pd
+import os
+import copy
+
+from ....modules.ts_forecast.model_list import MODELS
+from ...common.batch_sampler import TSBatchSampler
+from ...common.reader import ReadTS
+from ..common import (
+    TSCutOff,
+    BuildTSDataset,
+    TSNormalize,
+    TimeFeature,
+    TStoArray,
+    TStoBatch,
+    StaticInfer,
+)
+from .processors import ArraytoTS, TSDeNormalize
+from ..base import BasicPredictor
+from .result import TSFcResult
+
+
+class TSFcPredictor(BasicPredictor):
+    """TSFcPredictor that inherits from BasicPredictor."""
+
+    entities = MODELS
+
+    def __init__(self, *args: List, **kwargs: Dict) -> None:
+        """Initializes TSFcPredictor.
+
+        Args:
+            *args: Arbitrary positional arguments passed to the superclass.
+            **kwargs: Arbitrary keyword arguments passed to the superclass.
+        """
+        super().__init__(*args, **kwargs)
+        self.preprocessors, self.infer, self.postprocessors = self._build()
+
+    def _build_batch_sampler(self) -> TSBatchSampler:
+        """Builds and returns an ImageBatchSampler instance.
+
+        Returns:
+            ImageBatchSampler: An instance of ImageBatchSampler.
+        """
+        return TSBatchSampler()
+
+    def _get_result_class(self) -> type:
+        """Returns the result class, TopkResult.
+
+        Returns:
+            type: The TopkResult class.
+        """
+        return TSFcResult
+
+    def _build(self) -> Tuple:
+        """Build the preprocessors, inference engine, and postprocessors based on the configuration.
+
+        Returns:
+            tuple: A tuple containing the preprocessors, inference engine, and postprocessors.
+        """
+        preprocessors = {
+            "ReadTS": ReadTS(),
+            "TSCutOff": TSCutOff(self.config["size"]),
+        }
+
+        if self.config.get("scale", None):
+            scaler_file_path = os.path.join(self.model_dir, "scaler.pkl")
+            if not os.path.exists(scaler_file_path):
+                raise Exception(f"Cannot find scaler file: {scaler_file_path}")
+            preprocessors["TSNormalize"] = TSNormalize(
+                scaler_file_path, self.config["info_params"]
+            )
+
+        preprocessors["BuildTSDataset"] = BuildTSDataset(self.config["info_params"])
+
+        if self.config.get("time_feat", None):
+            preprocessors["TimeFeature"] = TimeFeature(
+                self.config["info_params"],
+                self.config["size"],
+                self.config["holiday"],
+            )
+        preprocessors["TStoArray"] = TStoArray(self.config["input_data"])
+        preprocessors["TStoBatch"] = TStoBatch()
+        infer = StaticInfer(
+            model_dir=self.model_dir,
+            model_prefix=self.MODEL_FILE_PREFIX,
+            option=self.pp_option,
+        )
+        postprocessors = {}
+        postprocessors["ArraytoTS"] = ArraytoTS(self.config["info_params"])
+        if self.config.get("scale", None):
+            scaler_file_path = os.path.join(self.model_dir, "scaler.pkl")
+            if not os.path.exists(scaler_file_path):
+                raise Exception(f"Cannot find scaler file: {scaler_file_path}")
+            postprocessors["TSDeNormalize"] = TSDeNormalize(
+                scaler_file_path, self.config["info_params"]
+            )
+        return preprocessors, infer, postprocessors
+
+    def process(self, batch_data: List[Union[str, pd.DataFrame]]) -> Dict[str, Any]:
+        """
+        Process a batch of data through the preprocessing, inference, and postprocessing.
+
+        Args:
+            batch_data (List[Union[str, pd.DataFrame], ...]): A batch of input data (e.g., image file paths).
+
+        Returns:
+            dict: A dictionary containing the input path, raw image, class IDs, scores, and label names for every instance of the batch. Keys include 'input_path', 'input_img', 'class_ids', 'scores', and 'label_names'.
+        """
+
+        batch_raw_ts = self.preprocessors["ReadTS"](ts_list=batch_data)
+        batch_raw_ts_ori = copy.deepcopy(batch_raw_ts)
+        batch_cutoff_ts = self.preprocessors["TSCutOff"](ts_list=batch_raw_ts)
+
+        if "TSNormalize" in self.preprocessors:
+            batch_ts = self.preprocessors["TSNormalize"](ts_list=batch_cutoff_ts)
+            batch_input_ts = self.preprocessors["BuildTSDataset"](ts_list=batch_ts)
+        else:
+            batch_input_ts = self.preprocessors["BuildTSDataset"](
+                ts_list=batch_cutoff_ts
+            )
+
+        if "TimeFeature" in self.preprocessors:
+            batch_ts = self.preprocessors["TimeFeature"](ts_list=batch_input_ts)
+            batch_ts = self.preprocessors["TStoArray"](ts_list=batch_ts)
+        else:
+            batch_ts = self.preprocessors["TStoArray"](ts_list=batch_input_ts)
+
+        x = self.preprocessors["TStoBatch"](ts_list=batch_ts)
+        batch_preds = self.infer(x=x)
+
+        batch_ts_preds = self.postprocessors["ArraytoTS"](
+            ori_ts_list=batch_input_ts, pred_list=batch_preds
+        )
+        if "TSDeNormalize" in self.postprocessors:
+            batch_ts_preds = self.postprocessors["TSDeNormalize"](
+                preds_list=batch_ts_preds
+            )
+
+        return {
+            "input_path": batch_data,
+            "input_ts": batch_raw_ts,
+            "cutoff_ts": batch_raw_ts_ori,
+            "forecast": batch_ts_preds,
+        }