time_series_regression_pipeline#

时间序列回归问题的管道基类。

模块内容#

类摘要#

TimeSeriesRegressionPipeline

时间序列回归问题的管道基类。

目录#

class evalml.pipelines.time_series_regression_pipeline.TimeSeriesRegressionPipeline(component_graph, parameters=None, custom_name=None, random_seed=0)[source]#

时间序列回归问题的管道基类。

参数

component_graph (ComponentGraph, list, dict) – ComponentGraph 实例，有序的组件列表，或组件字典。接受列表中的字符串或 ComponentBase 子类。请注意，当列表中指定重复的组件时，重复的组件名称将使用组件在列表中的索引进行修改。例如，组件图 [Imputer, One Hot Encoder, Imputer, Logistic Regression Classifier] 将具有名称 [“Imputer”, “One Hot Encoder”, “Imputer_2”, “Logistic Regression Classifier”]
parameters (dict) – 字典，其中组件名称作为键，该组件的参数字典作为值。空字典 {} 表示对组件参数使用所有默认值。管道级别的参数，例如 time_index、gap 和 max_delay 必须使用“pipeline”键指定。例如：Pipeline(parameters={“pipeline”: {“time_index”: “Date”, “max_delay”: 4, “gap”: 2}})。
random_seed (int) – 随机数生成器的种子。默认为 0。

示例

>>> pipeline = TimeSeriesRegressionPipeline(component_graph=["Simple Imputer", "Linear Regressor"],
...                                                       parameters={"Simple Imputer": {"impute_strategy": "mean"},
...                                                                   "pipeline": {"gap": 1, "max_delay": 1, "forecast_horizon": 1, "time_index": "date"}},
...                                                       custom_name="My TimeSeriesRegression Pipeline")
...
>>> assert pipeline.custom_name == "My TimeSeriesRegression Pipeline"
>>> assert pipeline.component_graph.component_dict.keys() == {'Simple Imputer', 'Linear Regressor'}

管道参数将从每个组件的默认参数中选择，除非像上面那样传入了特定的参数。

>>> assert pipeline.parameters == {
...     'Simple Imputer': {'impute_strategy': 'mean', 'fill_value': None},
...     'Linear Regressor': {'fit_intercept': True, 'n_jobs': -1},
...     'pipeline': {'gap': 1, 'max_delay': 1, 'forecast_horizon': 1, 'time_index': "date"}}

属性

NO_PREDS_PI_ESTIMATORS	ProblemTypes.TIME_SERIES_REGRESSION
problem_type	None

方法

`can_tune_threshold_with_objective`	确定二元分类管道的阈值是否可以调优。
`clone`	构造一个新的管道，具有相同的组件、参数和随机种子。
`create_objectives`	从字符串列表或目标类创建目标实例。
`custom_name`	管道的自定义名称。
`dates_needed_for_prediction`	返回预测未来给定日期所需日期。
`dates_needed_for_prediction_range`	返回预测未来给定日期所需日期。
`describe`	输出管道详细信息，包括组件参数。
`feature_importance`	与每个特征相关的特征重要性。特征选择丢弃的特征被排除在外。
`fit`	拟合时间序列管道。
`fit_transform`	拟合并转换组件图中的所有组件，如果所有组件都是 Transformer。
`get_component`	按名称返回组件。
`get_forecast_period`	根据 X 中的最新数据点生成所有可能的预测时间点。
`get_forecast_predictions`	根据 X 的最后一个周期生成所有可能的预测结果。
`get_hyperparameter_ranges`	以字典形式返回所有组件的超参数范围。
`get_prediction_intervals`	使用拟合的回归器查找预测区间。
`graph`	生成表示管道图的图像。
`graph_dict`	生成一个字典，其中节点由组件名称和参数组成，边详细说明组件关系。在大多数情况下，此字典是 JSON 可序列化的。
`graph_feature_importance`	生成管道特征重要性的柱状图。
`inverse_transform`	按逆序将组件 inverse_transform 方法应用于估计器预测。
`load`	加载文件路径处的管道。
`model_family`	返回此管道的模型族。
`name`	管道名称。
`new`	构造一个具有相同组件图但参数集不同的新管道实例。不要与 Python 的 __new__ 方法混淆。
`parameters`	此管道的参数字典。
`predict`	对目标未知的未来数据进行预测。
`predict_in_sample`	对目标已知未来数据进行预测，例如交叉验证。
`save`	将管道保存到文件路径。
`score`	评估模型在当前目标和附加目标上的性能。
`summary`	管道结构的简短摘要，描述使用的组件列表。
`transform`	转换输入。
`transform_all_but_final`	通过应用所有预处理组件来转换数据。

can_tune_threshold_with_objective(self, objective)#

确定二元分类管道的阈值是否可以调优。

参数: objective (ObjectiveBase) – 主要的 AutoMLSearch 目标。
返回: 如果管道阈值可以调优，则返回 True。
返回类型: bool

clone(self)#

构造一个新的管道，具有相同的组件、参数和随机种子。

返回: 此管道的一个新实例，具有相同的组件、参数和随机种子。

static create_objectives(objectives)#: 从字符串列表或目标类创建目标实例。

property custom_name(self)#: 管道的自定义名称。

dates_needed_for_prediction(self, date)#

返回预测未来给定日期所需日期。

参数: date (pd.Timestamp) – 要在未来预测的日期。
返回: 预测给定日期所需的日期范围。
返回类型: dates_needed (tuple(pd.Timestamp))

dates_needed_for_prediction_range(self, start_date, end_date)#

返回预测未来给定日期所需日期。

参数

start_date (pd.Timestamp) – 要在未来预测的范围的开始日期。
end_date (pd.Timestamp) – 要在未来预测的范围的结束日期。

返回

预测给定日期所需的日期范围。

返回类型

dates_needed (tuple(pd.Timestamp))

抛出

ValueError – 如果 start_date 不在 end_date 之前

describe(self, return_dict=False)#

输出管道详细信息，包括组件参数。

参数: return_dict (bool) – 如果为 True，则返回关于管道信息的字典。默认为 False。
返回: 如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。
返回类型: dict

property feature_importance(self)#

与每个特征相关的特征重要性。特征选择丢弃的特征被排除在外。

返回: 特征名称及其对应的重要性
返回类型: pd.DataFrame

fit(self, X, y)[source]#

拟合时间序列管道。

参数

X (pd.DataFrame or np.ndarray) – 输入训练数据，形状为 [n_samples, n_features]。
y (pd.Series, np.ndarray) – 目标训练标签，长度为 [n_samples]。

返回

self

抛出

ValueError – 如果目标不是数字。

fit_transform(self, X, y)#

拟合并转换组件图中的所有组件，如果所有组件都是 Transformer。

参数

X (pd.DataFrame) – 输入特征，形状为 [n_samples, n_features]。
y (pd.Series) – 目标数据，长度为 [n_samples]。

返回

转换后的输出。

返回类型

pd.DataFrame

抛出

ValueError – 如果最后一个组件是 Estimator。

get_component(self, name)#

按名称返回组件。

参数: name (str) – 组件名称。
返回: 要返回的组件
返回类型: Component

get_forecast_period(self, X)[source]#

根据 X 中的最新数据点生成所有可能的预测时间点。

参数: X (pd.DataFrame, np.ndarray) – 训练管道时使用的数据，形状为 [n_samples_train, n_feautures]。
抛出: ValueError – 如果管道未训练。
返回: 从 gap 到 forecast_horizon + gap 的日期时间周期。
返回类型: pd.Series

示例

>>> X = pd.DataFrame({'date': pd.date_range(start='1-1-2022', periods=10, freq='D'), 'feature': range(10, 20)})
>>> y = pd.Series(range(0, 10), name='target')
>>> gap = 1
>>> forecast_horizon = 2
>>> pipeline = TimeSeriesRegressionPipeline(component_graph=["Linear Regressor"],
...                                         parameters={"Simple Imputer": {"impute_strategy": "mean"},
...                                                     "pipeline": {"gap": gap, "max_delay": 1, "forecast_horizon": forecast_horizon, "time_index": "date"}},
...                                        )
>>> pipeline.fit(X, y)
pipeline = TimeSeriesRegressionPipeline(component_graph={'Linear Regressor': ['Linear Regressor', 'X', 'y']}, parameters={'Linear Regressor':{'fit_intercept': True, 'n_jobs': -1}, 'pipeline':{'gap': 1, 'max_delay': 1, 'forecast_horizon': 2, 'time_index': 'date'}}, random_seed=0)
>>> dates = pipeline.get_forecast_period(X)
>>> expected = pd.Series(pd.date_range(start='2022-01-11', periods=forecast_horizon, freq='D').shift(gap), name='date', index=[10, 11])
>>> assert dates.equals(expected)

get_forecast_predictions(self, X, y)[source]#

根据 X 的最后一个周期生成所有可能的预测结果。

参数

X (pd.DataFrame, np.ndarray) – 训练管道时使用的数据，形状为 [n_samples_train, n_feautures]。
y (pd.Series, np.ndarray) – 用于训练管道的目标，形状为 [n_samples_train]。

返回

从 gap 周期到 forecast_horizon + gap 周期的预测。

get_hyperparameter_ranges(self, custom_hyperparameters)#

以字典形式返回所有组件的超参数范围。

参数: custom_hyperparameters (dict) – 管道的自定义超参数。
返回: 管道中每个组件的超参数范围字典。
返回类型: dict

get_prediction_intervals(self, X, y=None, X_train=None, y_train=None, coverage=None)[source]#

使用拟合的回归器查找预测区间。

此函数获取拟合的估计器的预测，并使用窗口大小为 5 的滚动标准差计算所有预测的滚动标准差。较低和较高的预测通过取每个边界处下尾概率的百分点（分位数）函数乘以滚动标准差确定。

某些估计器（Extra Trees Estimator、XGBoost Estimator、Prophet Estimator、ARIMA 和 Exponential Smoothing estimator）使用不同的方法计算预测区间。请参阅这些估计器的文档以了解更多信息。

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
y (pd.Series) – 目标数据。
X_train (pd.DataFrame, np.ndarray) – 训练管道时使用的数据，形状为 [n_samples_train, n_features]。
y_train (pd.Series, np.ndarray) – 用于训练管道的目标，形状为 [n_samples_train]。
coverage (list[float]) – 一个介于 0 和 1 之间的浮点数列表，应为其计算预测区间的上下界。

返回

预测区间，键的格式为 {coverage}_lower 或 {coverage}_upper。

返回类型

dict

抛出

MethodPropertyNotFoundError – 如果估计器不支持时间序列回归作为问题类型。

graph(self, filepath=None)#

生成表示管道图的图像。

参数

filepath (str, optional) – 图应保存到的路径。如果设置为 None（默认），则不保存图。

返回

可以直接在 Jupyter Notebook 中显示的图对象。

返回类型

graphviz.Digraph

抛出

RuntimeError – 如果 graphviz 未安装。
ValueError – 如果路径不可写。

graph_dict(self)#

生成一个字典，其中节点由组件名称和参数组成，边详细说明组件关系。在大多数情况下，此字典是 JSON 可序列化的。

x_edges 指定从哪个组件传递特征数据。y_edges 指定从哪个组件传递目标数据。这可用于在各种可视化工具中构建图。模板：{“Nodes”: {“component_name”: {“Name”: class_name, “Parameters”: parameters_attributes}, …}}, “x_edges”: [[from_component_name, to_component_name], [from_component_name, to_component_name], …], “y_edges”: [[from_component_name, to_component_name], [from_component_name, to_component_name], …]}

返回: 表示 DAG 结构的字典。
返回类型: dag_dict (dict)

graph_feature_importance(self, importance_threshold=0)#

生成管道特征重要性的柱状图。

参数: importance_threshold (float, optional) – 如果提供，则绘制其置换重要性绝对值大于 importance_threshold 的特征。默认为零。
返回: 显示特征及其对应重要性的柱状图。
返回类型: plotly.Figure
抛出: ValueError – 如果重要性阈值无效。

inverse_transform(self, y)#

按逆序将组件 inverse_transform 方法应用于估计器预测。

实现 inverse_transform 的组件包括 PolynomialDecomposer、LogTransformer、LabelEncoder (tbd)。

参数: y (pd.Series) – 最终组件特征。
返回: 目标的逆转换。
返回类型: pd.Series

static load(file_path: Union[str, io.BytesIO])#

加载文件路径处的管道。

参数: file_path (str|BytesIO) – 加载文件路径或 BytesIO 对象。
返回: PipelineBase 对象

property model_family(self)#: 返回此管道的模型族。

property name(self)#: 管道名称。

new(self, parameters, random_seed=0)#

构造一个具有相同组件图但参数集不同的新管道实例。不要与 Python 的 __new__ 方法混淆。

参数

parameters (dict) – 字典，其中组件名称作为键，该组件的参数字典作为值。空字典或 None 表示对组件参数使用所有默认值。默认为 None。
random_seed (int) – 随机数生成器的种子。默认为 0。

返回

此管道的一个新实例，具有相同的组件。

property parameters(self)#

此管道的参数字典。

返回: 所有组件参数的字典。
返回类型: dict

predict(self, X, objective=None, X_train=None, y_train=None)#

对目标未知的未来数据进行预测。

参数

X (pd.DataFrame, or np.ndarray) – 数据，形状为 [n_samples, n_features]。
objective (Object or string) – 用于进行预测的目标对象或字符串。
X_train (pd.DataFrame or np.ndarray or None) – 训练数据。
y_train (pd.Series or None) – 训练标签。

抛出

ValueError – 如果 X_train 和/或 y_train 为 None，或者最后一个组件不是 Estimator。

返回

预测结果。

predict_in_sample(self, X, y, X_train, y_train, objective=None, calculating_residuals=False)#

对目标已知未来数据进行预测，例如交叉验证。

参数

X (pd.DataFrame or np.ndarray) – 未来数据，形状为 [n_samples, n_features]
y (pd.Series, np.ndarray) – 未来目标，形状为 [n_samples]
X_train (pd.DataFrame, np.ndarray) – 训练管道时使用的数据，形状为 [n_samples_train, n_feautures]
y_train (pd.Series, np.ndarray) – 用于训练管道的目标，形状为 [n_samples_train]
objective (ObjectiveBase, str, None) – 用于对预测概率进行阈值处理的目标，可选。
calculating_residuals (bool) – 是否调用 predict_in_sample 计算残差。这意味着 X 和 y 参数不是未来数据，而是实际的训练数据。

返回

估计的标签。

返回类型

pd.Series

抛出

ValueError – 如果最后一个组件不是 Estimator。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将管道保存到文件路径。

参数

file_path (str) – 文件保存位置。
pickle_protocol (int) – pickle 数据流格式。

score(self, X, y, objectives, X_train=None, y_train=None)[source]#

评估模型在当前目标和附加目标上的性能。

参数

X (pd.DataFrame or np.ndarray) – 数据，形状为 [n_samples, n_features]。
y (pd.Series) – 真实标签，长度为 [n_samples]。
objectives (list) – 要评分的目标的非空列表。
X_train (pd.DataFrame, np.ndarray) – 训练管道时使用的数据，形状为 [n_samples_train, n_feautures]。
y_train (pd.Series, np.ndarray) – 用于训练管道的目标，形状为 [n_samples_train]。

返回

目标评分的有序字典。

返回类型

dict

property summary(self)#

管道结构的简短摘要，描述使用的组件列表。

示例：带 Simple Imputer + One Hot Encoder 的逻辑回归分类器

返回: 描述管道结构的字符串。

transform(self, X, y=None)#

转换输入。

参数

X (pd.DataFrame, or np.ndarray) – 数据，形状为 [n_samples, n_features]。
y (pd.Series) – 目标数据，长度为 [n_samples]。默认为 None。

返回

转换后的输出。

返回类型

pd.DataFrame

transform_all_but_final(self, X, y=None, X_train=None, y_train=None, calculating_residuals=False)#

通过应用所有预处理组件来转换数据。

参数

X (pd.DataFrame) – 要转换为管道的输入数据。
y (pd.Series) – 对应于管道目标的标签。
X_train (pd.DataFrame) – 用于从过去的观测生成特征的训练数据。
y_train (pd.Series) – 用于从过去的观测生成特征的训练标签。
calculating_residuals (bool) – 是否调用 predict_in_sample 计算残差。这意味着 X 和 y 参数不是未来数据，而是实际的训练数据。

返回

新的转换后的特征。

返回类型

pd.DataFrame