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

paddlex/inference/models/text_recognition/__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 TextRecPredictor

paddlex/inference/models/text_recognition/predictor.py

@@ -0,0 +1,106 @@
+# 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 ....utils.func_register import FuncRegister
+from ....modules.text_recognition.model_list import MODELS
+from ...common.batch_sampler import ImageBatchSampler
+from ...common.reader import ReadImage
+from ..common import (
+    Resize,
+    ResizeByShort,
+    Normalize,
+    ToCHWImage,
+    StaticInfer,
+)
+from ..base import BasicPredictor
+from .processors import OCRReisizeNormImg, CTCLabelDecode, ToBatch
+from .result import TextRecResult
+
+
+class TextRecPredictor(BasicPredictor):
+
+    entities = MODELS
+
+    _FUNC_MAP = {}
+    register = FuncRegister(_FUNC_MAP)
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.pre_tfs, self.infer, self.post_op = self._build()
+
+    def _build_batch_sampler(self):
+        return ImageBatchSampler()
+
+    def _get_result_class(self):
+        return TextRecResult
+
+    def _build(self):
+        pre_tfs = {"Read": ReadImage(format="RGB")}
+        for cfg in self.config["PreProcess"]["transform_ops"]:
+            tf_key = list(cfg.keys())[0]
+            assert tf_key in self._FUNC_MAP
+            func = self._FUNC_MAP[tf_key]
+            args = cfg.get(tf_key, {})
+            name, op = func(self, **args) if args else func(self)
+            if op:
+                pre_tfs[name] = op
+        pre_tfs["ToBatch"] = ToBatch()
+
+        infer = StaticInfer(
+            model_dir=self.model_dir,
+            model_prefix=self.MODEL_FILE_PREFIX,
+            option=self.pp_option,
+        )
+
+        post_op = self.build_postprocess(**self.config["PostProcess"])
+        return pre_tfs, infer, post_op
+
+    def process(self, batch_data):
+        batch_raw_imgs = self.pre_tfs["Read"](imgs=batch_data.instances)
+        batch_imgs = self.pre_tfs["ReisizeNorm"](imgs=batch_raw_imgs)
+        x = self.pre_tfs["ToBatch"](imgs=batch_imgs)
+        batch_preds = self.infer(x=x)
+        texts, scores = self.post_op(batch_preds)
+        return {
+            "input_path": batch_data.input_paths,
+            "page_index": batch_data.page_indexes,
+            "input_img": batch_raw_imgs,
+            "rec_text": texts,
+            "rec_score": scores,
+        }
+
+    @register("DecodeImage")
+    def build_readimg(self, channel_first, img_mode):
+        assert channel_first == False
+        return "Read", ReadImage(format=img_mode)
+
+    @register("RecResizeImg")
+    def build_resize(self, image_shape):
+        return "ReisizeNorm", OCRReisizeNormImg(rec_image_shape=image_shape)
+
+    def build_postprocess(self, **kwargs):
+        if kwargs.get("name") == "CTCLabelDecode":
+            return CTCLabelDecode(
+                character_list=kwargs.get("character_dict"),
+            )
+        else:
+            raise Exception()
+
+    @register("MultiLabelEncode")
+    def foo(self, *args, **kwargs):
+        return None, None
+
+    @register("KeepKeys")
+    def foo(self, *args, **kwargs):
+        return None, None

paddlex/inference/models/text_recognition/processors.py

@@ -0,0 +1,231 @@
+# 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 typing import List
+
+import re
+import numpy as np
+from PIL import Image
+import cv2
+import math
+import json
+import tempfile
+from tokenizers import Tokenizer as TokenizerFast
+
+from ....utils import logging
+
+
+class OCRReisizeNormImg:
+    """for ocr image resize and normalization"""
+
+    def __init__(self, rec_image_shape=[3, 48, 320]):
+        super().__init__()
+        self.rec_image_shape = rec_image_shape
+        self.max_imgW = 3200
+
+    def resize_norm_img(self, img, max_wh_ratio):
+        """resize and normalize the img"""
+        imgC, imgH, imgW = self.rec_image_shape
+        assert imgC == img.shape[2]
+        imgW = int((imgH * max_wh_ratio))
+        if imgW > self.max_imgW:
+            resized_image = cv2.resize(img, (self.max_imgW, imgH))
+            resized_w = self.max_imgW
+            imgW = self.max_imgW
+        else:
+            h, w = img.shape[:2]
+            ratio = w / float(h)
+            if math.ceil(imgH * ratio) > imgW:
+                resized_w = imgW
+            else:
+                resized_w = int(math.ceil(imgH * ratio))
+            resized_image = cv2.resize(img, (resized_w, imgH))
+        resized_image = resized_image.astype("float32")
+        resized_image = resized_image.transpose((2, 0, 1)) / 255
+        resized_image -= 0.5
+        resized_image /= 0.5
+        padding_im = np.zeros((imgC, imgH, imgW), dtype=np.float32)
+        padding_im[:, :, 0:resized_w] = resized_image
+        return padding_im
+
+    def __call__(self, imgs):
+        """apply"""
+        return [self.resize(img) for img in imgs]
+
+    def resize(self, img):
+        imgC, imgH, imgW = self.rec_image_shape
+        max_wh_ratio = imgW / imgH
+        h, w = img.shape[:2]
+        wh_ratio = w * 1.0 / h
+        max_wh_ratio = max(max_wh_ratio, wh_ratio)
+        img = self.resize_norm_img(img, max_wh_ratio)
+        return img
+
+
+class BaseRecLabelDecode:
+    """Convert between text-label and text-index"""
+
+    def __init__(self, character_str=None, use_space_char=True):
+        super().__init__()
+        self.reverse = False
+        character_list = (
+            list(character_str)
+            if character_str is not None
+            else list("0123456789abcdefghijklmnopqrstuvwxyz")
+        )
+        if use_space_char:
+            character_list.append(" ")
+
+        character_list = self.add_special_char(character_list)
+        self.dict = {}
+        for i, char in enumerate(character_list):
+            self.dict[char] = i
+        self.character = character_list
+
+    def pred_reverse(self, pred):
+        """pred_reverse"""
+        pred_re = []
+        c_current = ""
+        for c in pred:
+            if not bool(re.search("[a-zA-Z0-9 :*./%+-]", c)):
+                if c_current != "":
+                    pred_re.append(c_current)
+                pred_re.append(c)
+                c_current = ""
+            else:
+                c_current += c
+        if c_current != "":
+            pred_re.append(c_current)
+
+        return "".join(pred_re[::-1])
+
+    def add_special_char(self, character_list):
+        """add_special_char"""
+        return character_list
+
+    def decode(self, text_index, text_prob=None, is_remove_duplicate=False):
+        """convert text-index into text-label."""
+        result_list = []
+        ignored_tokens = self.get_ignored_tokens()
+        batch_size = len(text_index)
+        for batch_idx in range(batch_size):
+            selection = np.ones(len(text_index[batch_idx]), dtype=bool)
+            if is_remove_duplicate:
+                selection[1:] = text_index[batch_idx][1:] != text_index[batch_idx][:-1]
+            for ignored_token in ignored_tokens:
+                selection &= text_index[batch_idx] != ignored_token
+
+            char_list = [
+                self.character[text_id] for text_id in text_index[batch_idx][selection]
+            ]
+            if text_prob is not None:
+                conf_list = text_prob[batch_idx][selection]
+            else:
+                conf_list = [1] * len(selection)
+            if len(conf_list) == 0:
+                conf_list = [0]
+
+            text = "".join(char_list)
+
+            if self.reverse:  # for arabic rec
+                text = self.pred_reverse(text)
+
+            result_list.append((text, np.mean(conf_list).tolist()))
+        return result_list
+
+    def get_ignored_tokens(self):
+        """get_ignored_tokens"""
+        return [0]  # for ctc blank
+
+    def __call__(self, pred):
+        """apply"""
+        preds = np.array(pred)
+        if isinstance(preds, tuple) or isinstance(preds, list):
+            preds = preds[-1]
+        preds_idx = preds.argmax(axis=-1)
+        preds_prob = preds.max(axis=-1)
+        text = self.decode(preds_idx, preds_prob, is_remove_duplicate=True)
+        texts = []
+        scores = []
+        for t in text:
+            texts.append(t[0])
+            scores.append(t[1])
+        return texts, scores
+
+
+class CTCLabelDecode(BaseRecLabelDecode):
+    """Convert between text-label and text-index"""
+
+    def __init__(self, character_list=None, use_space_char=True):
+        super().__init__(character_list, use_space_char=use_space_char)
+
+    def __call__(self, pred):
+        """apply"""
+        preds = np.array(pred[0])
+        preds_idx = preds.argmax(axis=-1)
+        preds_prob = preds.max(axis=-1)
+        text = self.decode(preds_idx, preds_prob, is_remove_duplicate=True)
+        texts = []
+        scores = []
+        for t in text:
+            texts.append(t[0])
+            scores.append(t[1])
+        return texts, scores
+
+    def add_special_char(self, character_list):
+        """add_special_char"""
+        character_list = ["blank"] + character_list
+        return character_list
+
+
+class ToBatch:
+    """A class for batching and padding images to a uniform width."""
+
+    def __pad_imgs(self, imgs: List[np.ndarray]) -> List[np.ndarray]:
+        """Pad images to the maximum width in the batch.
+
+        Args:
+            imgs (list of np.ndarrays): List of images to pad.
+
+        Returns:
+            list of np.ndarrays: List of padded images.
+        """
+        max_width = max(img.shape[2] for img in imgs)
+        padded_imgs = []
+        for img in imgs:
+            _, height, width = img.shape
+            pad_width = max_width - width
+            padded_img = np.pad(
+                img,
+                ((0, 0), (0, 0), (0, pad_width)),
+                mode="constant",
+                constant_values=0,
+            )
+            padded_imgs.append(padded_img)
+        return padded_imgs
+
+    def __call__(self, imgs: List[np.ndarray]) -> List[np.ndarray]:
+        """Call method to pad images and stack them into a batch.
+
+        Args:
+            imgs (list of np.ndarrays): List of images to process.
+
+        Returns:
+            list of np.ndarrays: List containing a stacked tensor of the padded images.
+        """
+        imgs = self.__pad_imgs(imgs)
+        return [np.stack(imgs, axis=0).astype(dtype=np.float32, copy=False)]

paddlex/inference/models/text_recognition/result.py

@@ -0,0 +1,75 @@
+# 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 copy
+import PIL
+from PIL import Image, ImageDraw, ImageFont
+
+from ....utils.fonts import PINGFANG_FONT_FILE_PATH
+from ...common.result import BaseCVResult, StrMixin, JsonMixin
+
+
+class TextRecResult(BaseCVResult):
+
+    def _to_str(self, *args, **kwargs):
+        data = copy.deepcopy(self)
+        data.pop("input_img")
+        return JsonMixin._to_str(data, *args, **kwargs)
+
+    def _to_json(self, *args, **kwargs):
+        data = copy.deepcopy(self)
+        data.pop("input_img")
+        return JsonMixin._to_json(data, *args, **kwargs)
+
+    def _to_img(self):
+        """Draw label on image"""
+        image = Image.fromarray(self["input_img"])
+        rec_text = self["rec_text"]
+        rec_score = self["rec_score"]
+        image = image.convert("RGB")
+        image_width, image_height = image.size
+        text = f"{rec_text} ({rec_score})"
+        font = self.adjust_font_size(image_width, text, PINGFANG_FONT_FILE_PATH)
+        row_height = font.getbbox(text)[3]
+        new_image_height = image_height + int(row_height * 1.2)
+        new_image = Image.new("RGB", (image_width, new_image_height), (255, 255, 255))
+        new_image.paste(image, (0, 0))
+
+        draw = ImageDraw.Draw(new_image)
+        draw.text(
+            (0, image_height),
+            text,
+            fill=(0, 0, 0),
+            font=font,
+        )
+        return {"res": new_image}
+
+    def adjust_font_size(self, image_width, text, font_path):
+        font_size = int(image_width * 0.06)
+        font = ImageFont.truetype(font_path, font_size)
+
+        if int(PIL.__version__.split(".")[0]) < 10:
+            text_width, _ = font.getsize(text)
+        else:
+            text_width, _ = font.getbbox(text)[2:]
+
+        while text_width > image_width:
+            font_size -= 1
+            font = ImageFont.truetype(font_path, font_size)
+            if int(PIL.__version__.split(".")[0]) < 10:
+                text_width, _ = font.getsize(text)
+            else:
+                text_width, _ = font.getbbox(text)[2:]
+
+        return font

paddlex/inference/models/ts_anomaly_detection/__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 TSAdPredictor

paddlex/inference/models/ts_anomaly_detection/predictor.py

@@ -0,0 +1,146 @@
+# 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
+
+from ....modules.ts_anomaly_detection.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 GetAnomaly
+from ..base import BasicPredictor
+from .result import TSAdResult
+
+
+class TSAdPredictor(BasicPredictor):
+    """TSAdPredictor that inherits from BasicPredictor."""
+
+    entities = MODELS
+
+    def __init__(self, *args: List, **kwargs: Dict) -> None:
+        """Initializes TSAdPredictor.
+
+        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 TSAdResult
+
+    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["GetAnomaly"] = GetAnomaly(
+            self.config["model_threshold"], 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_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["GetAnomaly"](
+            ori_ts_list=batch_input_ts, pred_list=batch_preds
+        )
+        return {
+            "input_path": batch_data,
+            "input_ts": batch_raw_ts,
+            "anomaly": batch_ts_preds,
+        }

paddlex/inference/models/ts_anomaly_detection/processors.py

@@ -0,0 +1,94 @@
+# 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
+import numpy as np
+import pandas as pd
+
+
+class GetAnomaly:
+    """A class to detect anomalies in time series data based on a model threshold."""
+
+    def __init__(self, model_threshold: float, info_params: Dict[str, Any]):
+        """
+        Initializes the GetAnomaly class with a model threshold and parameters information.
+
+        Args:
+            model_threshold (float): The threshold for determining anomalies.
+            info_params (Dict[str, Any]): Configuration parameters including target columns and time column name.
+        """
+        super().__init__()
+        self.model_threshold = model_threshold
+        self.info_params = info_params
+
+    def __call__(
+        self, ori_ts_list: List[Dict[str, Any]], pred_list: List[np.ndarray]
+    ) -> List[pd.DataFrame]:
+        """
+        Detects anomalies for a list of time series predictions.
+
+        Args:
+            ori_ts_list (List[Dict[str, Any]]): Original time series data for each prediction, including past and covariate information.
+            pred_list (List[np.ndarray]): List of prediction arrays corresponding to each time series in ori_ts_list.
+
+        Returns:
+            List[pd.DataFrame]: A list of DataFrames, each containing anomaly labels for the time series.
+        """
+        return [
+            self.getanomaly(ori_ts, pred)
+            for ori_ts, pred in zip(ori_ts_list, pred_list)
+        ]
+
+    def getanomaly(self, ori_ts: Dict[str, Any], pred: np.ndarray) -> pd.DataFrame:
+        """
+        Detects anomalies in a single time series prediction.
+
+        Args:
+            ori_ts (Dict[str, Any]): Original time series data for a single time series.
+            pred (np.ndarray): Prediction array for the given time series.
+
+        Returns:
+            pd.DataFrame: A DataFrame containing anomaly labels for the time series.
+
+        Raises:
+            ValueError: If none of the expected keys are found in ori_ts.
+        """
+        pred = pred[0]
+        if ori_ts.get("past_target", None) is not None:
+            ts = ori_ts["past_target"]
+        elif ori_ts.get("observed_cov_numeric", None) is not None:
+            ts = ori_ts["observed_cov_numeric"]
+        elif ori_ts.get("known_cov_numeric", None) is not None:
+            ts = ori_ts["known_cov_numeric"]
+        elif ori_ts.get("static_cov_numeric", None) is not None:
+            ts = ori_ts["static_cov_numeric"]
+        else:
+            raise ValueError("No value in ori_ts")
+        column_name = (
+            self.info_params["target_cols"]
+            if "target_cols" in self.info_params
+            else self.info_params["feature_cols"]
+        )
+
+        anomaly_score = np.mean(np.square(pred - np.array(ts)), axis=-1)
+        anomaly_label = (anomaly_score >= self.model_threshold) + 0
+
+        past_target_index = ts.index
+        past_target_index.name = self.info_params["time_col"]
+        anomaly_label_df = pd.DataFrame(
+            np.reshape(anomaly_label, newshape=[pred.shape[0], -1]),
+            index=past_target_index,
+            columns=["label"],
+        )
+        return anomaly_label_df