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

paddlex/inference/models/ts_classification/predictor.py

@@ -0,0 +1,122 @@
+# 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 copy
+import os
+from typing import Any, Dict, List, Tuple, Union
+
+import pandas as pd
+
+from ....modules.ts_classification.model_list import MODELS
+from ...common.batch_sampler import TSBatchSampler
+from ...common.reader import ReadTS
+from ..base import BasePredictor
+from ..common import BuildTSDataset, TSCutOff, TSNormalize, TStoArray, TStoBatch
+from .processors import BuildPadMask, GetCls
+from .result import TSClsResult
+
+
+class TSClsPredictor(BasePredictor):
+    """TSClsPredictor that inherits from BasePredictor."""
+
+    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 = self.create_static_infer()
+        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.instances)
+        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_paths,
+            "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,122 @@
+# 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.
+
+from typing import Any, Dict, List
+
+import numpy as np
+import pandas as pd
+
+from ...utils.benchmark import benchmark
+
+
+@benchmark.timeit
+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
+
+
+@benchmark.timeit
+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,87 @@
+# 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 io
+from typing import Any
+
+from PIL import Image
+
+from ....utils.deps import function_requires_deps, is_dep_available
+from ...common.result import BaseTSResult
+
+if is_dep_available("matplotlib"):
+    import matplotlib.pyplot as plt
+
+
+@function_requires_deps("matplotlib")
+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.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 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.
+
+from .predictor import TSFcPredictor

paddlex/inference/models/ts_forecasting/predictor.py

@@ -0,0 +1,154 @@
+# 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 copy
+import os
+from typing import Any, Dict, List, Tuple, Union
+
+import pandas as pd
+
+from ....modules.ts_forecast.model_list import MODELS
+from ...common.batch_sampler import TSBatchSampler
+from ...common.reader import ReadTS
+from ..base import BasePredictor
+from ..common import (
+    BuildTSDataset,
+    TimeFeature,
+    TSCutOff,
+    TSNormalize,
+    TStoArray,
+    TStoBatch,
+)
+from .processors import ArraytoTS, TSDeNormalize
+from .result import TSFcResult
+
+
+class TSFcPredictor(BasePredictor):
+    """TSFcPredictor that inherits from BasePredictor."""
+
+    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 = self.create_static_infer()
+        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.instances)
+        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_paths,
+            "input_ts": batch_raw_ts,
+            "cutoff_ts": batch_raw_ts_ori,
+            "forecast": batch_ts_preds,
+        }

paddlex/inference/models/ts_forecasting/processors.py

@@ -0,0 +1,158 @@
+# 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.
+
+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
+
+if is_dep_available("joblib"):
+    import joblib
+
+
+@benchmark.timeit
+@class_requires_deps("joblib")
+class TSDeNormalize:
+    """A class to de-normalize time series prediction data using a pre-fitted scaler."""
+
+    def __init__(self, scale_path: str, params_info: dict):
+        """
+        Initializes the TSDeNormalize class with a scaler and parameters information.
+
+        Args:
+            scale_path (str): The file path to the serialized scaler object.
+            params_info (dict): Additional parameters information.
+        """
+        super().__init__()
+        self.scaler = joblib.load(scale_path)
+        self.params_info = params_info
+
+    def __call__(self, preds_list: List[pd.DataFrame]) -> List[pd.DataFrame]:
+        """
+        Applies de-normalization to a list of prediction DataFrames.
+
+        Args:
+            preds_list (List[pd.DataFrame]): A list of DataFrames containing normalized prediction data.
+
+        Returns:
+            List[pd.DataFrame]: A list of DataFrames with de-normalized prediction data.
+        """
+        return [self.tsdenorm(pred) for pred in preds_list]
+
+    def tsdenorm(self, pred: pd.DataFrame) -> pd.DataFrame:
+        """
+        De-normalizes a single prediction DataFrame.
+
+        Args:
+            pred (pd.DataFrame): A DataFrame containing normalized prediction data.
+
+        Returns:
+            pd.DataFrame: A DataFrame with de-normalized prediction data.
+        """
+        scale_cols = pred.columns.values.tolist()
+        pred[scale_cols] = self.scaler.inverse_transform(pred[scale_cols])
+        return pred
+
+
+@benchmark.timeit
+class ArraytoTS:
+    """A class to convert arrays of predictions into time series format."""
+
+    def __init__(self, info_params: Dict[str, Any]):
+        """
+        Initializes the ArraytoTS class with the given parameters.
+
+        Args:
+            info_params (Dict[str, Any]): Configuration parameters including target columns, frequency, and time column name.
+        """
+        super().__init__()
+        self.info_params = info_params
+
+    def __call__(
+        self, ori_ts_list: List[Dict[str, Any]], pred_list: List[np.ndarray]
+    ) -> List[pd.DataFrame]:
+        """
+        Converts a list of arrays to a list of time series DataFrames.
+
+        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 representing the forecasted time series.
+        """
+        return [
+            self.arraytots(ori_ts, pred) for ori_ts, pred in zip(ori_ts_list, pred_list)
+        ]
+
+    def arraytots(self, ori_ts: Dict[str, Any], pred: np.ndarray) -> pd.DataFrame:
+        """
+        Converts a single array prediction to a time series DataFrame.
+
+        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 representing the forecasted 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"]
+        )
+        if isinstance(self.info_params["freq"], str):
+            past_target_index = ts.index
+            if past_target_index.freq is None:
+                past_target_index.freq = pd.infer_freq(ts.index)
+            future_target_index = pd.date_range(
+                past_target_index[-1] + past_target_index.freq,
+                periods=pred.shape[0],
+                freq=self.info_params["freq"],
+                name=self.info_params["time_col"],
+            )
+        elif isinstance(self.info_params["freq"], int):
+            start_idx = max(ts.index) + 1
+            stop_idx = start_idx + pred.shape[0]
+            future_target_index = pd.RangeIndex(
+                start=start_idx,
+                stop=stop_idx,
+                step=self.info_params["freq"],
+                name=self.info_params["time_col"],
+            )
+
+        future_target = pd.DataFrame(
+            np.reshape(pred, newshape=[pred.shape[0], -1]),
+            index=future_target_index,
+            columns=column_name,
+        )
+        return future_target