def transform(self, Z, X=None):
self.check_is_fitted()
z = check_series(Z, enforce_univariate=True)
# Passing an alpha values other than None would return confidence intervals
# and break the signature of the series-to-series transformer
zt = acf(
z,
adjusted=self.adjusted,
nlags=self.n_lags,
qstat=self.qstat,
fft=self.fft,
alpha=None,
missing=self.missing,
)
return pd.Series(zt)
def _run_clasp(self, X):
X = check_series(X, enforce_univariate=True, allow_numpy=True)
if isinstance(X, pd.Series):
X = X.to_numpy()
clasp_transformer = ClaSPTransformer(
window_length=self.period_length).fit(X)
self.found_cps, self.profiles, self.scores = _segmentation(
X,
clasp_transformer,
n_change_points=self.n_cps,
exclusion_radius=0.05)
return self.found_cps, self.profiles, self.scores
def transform(self, Z, X=None):
"""
Parameters
----------
Z: pandas.Series
Time series dataset(lets say of length=n)
Returns
----------
Z: pandas.Series
Matrix Profile of time series as output with length as (n-window_length+1)
"""
self.check_is_fitted()
Z = check_series(Z, enforce_univariate=True)
Z = stumpy.stump(Z, self.window_length)
return pd.Series(Z[:, 0])
def inverse_transform(self, Z, X=None):
"""Inverse transform data.
Parameters
----------
Z : TimeSeries
Returns
-------
Zt : TimeSeries
Inverse-transformed time series.
"""
self.check_is_fitted()
Z = check_series(Z)
Zt = self.transformer_.inverse_transform(_from_series_to_2d_numpy(Z))
return _from_2d_numpy_to_series(Zt, index=Z.index)
def predict_scores(self, X):
"""Return scores for predicted annotations on test/deployment data.
Parameters
----------
X : pd.DataFrame
Data to annotate (time series).
Returns
-------
Y : pd.Series
Scores for sequence X exact format depends on annotation type.
"""
self.check_is_fitted()
X = check_series(X)
return self._predict_scores(X)
def fit(self, Z, X=None):
"""Fit data.
Iterates over columns (series) and applies
the fit function of the transformer.
Parameters
----------
Z : pd.Series, pd.DataFrame
Returns
-------
self : an instance of self
"""
self._is_fitted = False
z = check_series(Z, allow_numpy=False)
# cast to pd.DataFrame in univariate case
if isinstance(z, pd.Series):
z = z.to_frame()
# check that columns are None or list of strings
if self.columns is not None:
if not isinstance(self.columns, list) and all(
isinstance(s, str) for s in self.columns):
raise ValueError(
"Columns need to be a list of strings or None.")
# set self.columns_ to columns that are going to be transformed
# (all if self.columns is None)
self.columns_ = self.columns
if self.columns_ is None:
self.columns_ = z.columns
# make sure z contains all columns that the user wants to transform
_check_columns(z, selected_columns=self.columns_)
# fit by iterating over columns
self.transformers_ = {}
for colname in self.columns_:
transformer = clone(self.transformer)
self.transformers_[colname] = transformer
self.transformers_[colname].fit(z[colname], X)
self._is_fitted = True
return self
def update(self, Z, X=None, update_params=False):
"""Update fitted parameters
Parameters
----------
y : pd.Series
X : pd.DataFrame
update_params : bool, optional (default=False)
Returns
-------
self : an instance of self
"""
self.check_is_fitted()
z = check_series(Z, enforce_univariate=True)
self._set_y_index(z)
return self
def fit(self, Z, X=None):
"""Fit.
Parameters
----------
Z : TimeSeries
X : TimeSeries
Returns
-------
self
"""
Z = check_series(Z)
self.transformer_ = clone(self.transformer)
self.transformer_.fit(_from_series_to_2d_numpy(Z))
self._is_fitted = True
return self
def transform(self, Z, X=None):
"""Transform data.
Returns a transformed version of y.
Parameters
----------
y : pd.Series
Returns
-------
yt : pd.Series
Transformed time series.
"""
self.check_is_fitted()
Z = check_series(Z)
Zt = self.transformer_.transform(_from_series_to_2d_numpy(Z))
return _from_2d_numpy_to_series(Zt, index=Z.index)
def inverse_transform(self, Z, X=None):
"""Reverse transformation on input series `Z`.
Parameters
----------
Z : pd.Series or pd.DataFrame
A time series to reverse the transformation on.
Returns
-------
Z_inv : pd.Series or pd.DataFrame
The reconstructed timeseries after the transformation has been reversed.
"""
self.check_is_fitted()
Z = check_series(Z)
return self._inverse_transform(Z, X=X)
def transform(self, Z, X=None):
"""Return transformed version of input series `Z`.
Parameters
----------
Z : pd.Series or pd.DataFrame
A time series to apply the specified transformation on.
Returns
-------
Zt : pd.Series or pd.DataFrame
Transformed version of input series `Z`.
"""
self.check_is_fitted()
Z = check_series(Z)
return self._transform(Z, X=X)
def inverse_transform(self, Z, X=None):
"""Reverse transformation on input series `Z`.
Parameters
----------
Z : pd.Series or pd.DataFrame
A time series to reverse the transformation on.
X : pd.DataFrame, default=None
Exogenous data used in transformation.
Returns
-------
Z_inv : pd.Series or pd.DataFrame
The reconstructed timeseries after the transformation has been reversed.
"""
self.check_is_fitted()
Z = check_series(Z)
return self._get_inverse_transform(self.transformers_pre_, Z, X)
def transform(self, Z, X=None):
"""Transform series.
Parameters
----------
Z : pd.Series or pd.DataFrame
The series to transform.
Returns
-------
summary_value : pd.DataFrame
DataFrame where series are instances (rows) and calculated summary
values are treated as features (columns).
"""
self.check_is_fitted()
Z = check_series(Z)
summary_value = self._transform(Z, X=X)
return summary_value
def update(self, Z, X=None, update_params=False):
"""
Update the parameters of the detrending estimator with new data
Parameters
----------
y_new : pd.Series
New time series
update_params : bool, optional (default=False)
Update the parameters of the detrender model with
Returns
-------
self : an instance of self
"""
z = check_series(Z, enforce_univariate=True, allow_empty=True)
self.forecaster_.update(z, X, update_params=update_params)
return self
def transform(self, Z, X=None):
"""Tranform data.
Parameters
----------
Z: pd.Series
Time series of length n_timepoints
Returns
-------
Z: pd.Series
Matrix Profile of time series as output with length as
(n_timepoints-window_length+1)
"""
self.check_is_fitted()
Z = check_series(Z, enforce_univariate=True)
Z = stumpy.stump(Z, self.window_length)
return pd.Series(Z[:, 0])
def inverse_transform(self, Z, X=None):
"""Inverse transform data.
Parameters
----------
Z : pd.Series
Series to transform.
X : pd.DataFrame, optional (default=None)
Exogenous data used in transformation.
Returns
-------
Zt : pd.Series
Transformed data - the inverse of the Box-Cox transformation.
"""
self.check_is_fitted()
Z = check_series(Z)
return np.exp(Z)
def fit(self, Z, X=None):
"""Fit the transformation on input series `Z`.
Parameters
----------
Z : pd.Series or pd.DataFrame
A time series to apply the specified transformation on.
Returns
-------
self
"""
Z = check_series(Z)
self._fit(Z, X=X)
self._is_fitted = True
return self
def inverse_transform(self, Z, X=None):
"""Inverse transform data.
Returns a transformed version of y.
Parameters
----------
y : pd.Series
X : pd.DataFrame
Returns
-------
yt : pd.Series
Transformed time series.
"""
self.check_is_fitted()
z = check_series(Z, enforce_univariate=True)
seasonal = self._align_seasonal(z)
return self._inverse_transform(z, seasonal)
def _transform(self, Z, X=None):
"""Transform data.
Parameters
----------
Z : pd.Series
Series to transform.
X : pd.DataFrame, optional (default=None)
Exogenous data used in transformation.
Returns
-------
Zt : pd.Series
Transformed series.
"""
z = check_series(Z, enforce_univariate=True)
zt = boxcox(z.to_numpy(), self.lambda_)
return pd.Series(zt, index=z.index)
def transform(self, Z, X=None):
"""Transform data.
Parameters
----------
Z : pd.Series
Series to transform.
X : pd.DataFrame, optional (default=None)
Exogenous data used in transformation.
Returns
-------
Zt : pd.Series
Transformed series.
"""
self.check_is_fitted()
Z = check_series(Z)
return np.log(Z)
def transform(self, Z, X=None):
"""Transform data.
Returns a transformed version of y.
Parameters
----------
y : pd.Series
X : pd.DataFrame
Returns
-------
yt : pd.Series
Transformed time series.
"""
self.check_is_fitted()
z = check_series(Z, enforce_univariate=True)
return self._transform(z)
def transform(self, Z, X=None):
"""Transform data.
Parameters
----------
Z : pd.Series / pd.DataFrame
Series / DataFrame to transform.
X : pd.DataFrame, optional (default=None)
Exogenous data used in transformation.
Returns
-------
Zt : pd.Series / pd.DataFrame
Transformed data.
"""
self.check_is_fitted()
Z = check_series(Z)
return self._apply_function(Z, func=self.func, kw_args=self.kw_args)
def fit(self, Z, X=None):
"""Fit to data.
Parameters
----------
Z : pd.Series
X : pd.DataFrame
Returns
-------
self : an instance of self
"""
self._is_fitted = False
z = check_series(Z, enforce_univariate=True)
self._set_y_len(z)
self._set_y_index(z)
sp = check_sp(self.sp)
if sp > 1:
# apply seasonal decomposition
_seasonalizer = _STL(
z.values,
period=sp,
seasonal=self.seasonal,
trend=self.trend,
low_pass=self.low_pass,
seasonal_deg=self.seasonal_deg,
trend_deg=self.trend_deg,
low_pass_deg=self.low_pass_deg,
robust=self.robust,
seasonal_jump=self.seasonal_jump,
trend_jump=self.trend_jump,
low_pass_jump=self.low_pass_jump,
).fit()
self.stl_model = _seasonalizer
self.seasonal_ = self.stl_model.seasonal
else:
self.stl_model = None
self.seasonal_ = np.zeros_like(z.values)
self.seasonal_ = pd.Series(self.seasonal_, index=Z.index)
self._is_fitted = True
return self
def fit(self, Z, X=None):
"""Fit to data.
Parameters
----------
y_train : pd.Series
Returns
-------
self : an instance of self
"""
z = check_series(Z, enforce_univariate=True)
self._set_y_index(z)
sp = check_sp(self.sp)
# set default condition
if self.seasonality_test is None:
self.seasonality_test_ = autocorrelation_seasonality_test
else:
self.seasonality_test_ = self.seasonality_test
# check if data meets condition
self.is_seasonal_ = self._check_condition(z)
if self.is_seasonal_:
# if condition is met, apply de-seasonalisation
self.seasonal_ = seasonal_decompose(
z,
model=self.model,
period=sp,
filt=None,
two_sided=True,
extrapolate_trend=0,
).seasonal.iloc[:sp]
else:
# otherwise, set idempotent seasonal components
self.seasonal_ = (
np.zeros(self.sp) if self.model == "additive" else np.ones(self.sp)
)
self._is_fitted = True
return self
def transform(self, X, y=None):
"""
Takes as input a single time series dataset and returns the matrix profile
for that time series dataset.
Parameters
----------
X: pandas.Series
Time series dataset(lets say of length=n)
Returns
-------
Xt: pandas.Series
Matrix Profile of time series as output with length as (n-window_length+1)
"""
self.check_is_fitted()
X = check_series(X, enforce_univariate=True)
Xt = stumpy.stump(X, self.window_length)
return pd.Series(Xt[:, 0])
def inverse_transform(self, Z, X=None):
"""Inverse transform data.
Parameters
----------
Z : pd.Series
Series to transform.
X : pd.DataFrame, optional (default=None)
Exogenous data used in transformation.
Returns
-------
Zt : pd.Series
Transformed data - the inverse of the Box-Cox transformation.
"""
self.check_is_fitted()
z = check_series(Z, enforce_univariate=True)
zt = inv_boxcox(z.to_numpy(), self.lambda_)
return pd.Series(zt, index=z.index)
def transform(self, Z, X=None):
"""Transform data.
Returns a transformed version yt of y. The seasonal component is removed from y.
The trend and residual components can be accessed via
the attributes trend_ and resid_ for the fitted data.
Parameters
----------
y : pd.Series
X : pd.DataFrame
Returns
-------
yt : pd.Series
"""
self.check_is_fitted()
z = check_series(Z, enforce_univariate=True)
return self._transform(z)
def inverse_transform(self, Z, X=None):
"""Inverse transform data.
Parameters
----------
Z : pd.Series
Series to transform.
X : pd.DataFrame, optional (default=None)
Exogenous data used in transformation.
Returns
-------
z : pd.Series
Inverse transformed data.
"""
self.check_is_fitted()
z = check_series(Z, enforce_univariate=False)
if not self.passthrough:
z = self.transformer_.inverse_transform(z, X=X)
return z
def fit(self, Z, X=None):
"""
Compute the trend in the series
Parameters
----------
Y : pd.Series
Endogenous time series to fit a trend to.
X : pd.DataFrame, optional (default=None)
Exogenous variables
Returns
-------
self : an instance of self
"""
z = check_series(Z, enforce_univariate=True)
forecaster = clone(self.forecaster)
self.forecaster_ = forecaster.fit(z, X)
self._is_fitted = True
return self
def transform(self, Z, X=None):
"""Return transformed version of input series `Z`.
Parameters
----------
Z : pd.Series or pd.DataFrame
A time series to apply the transformation on.
X : pd.DataFrame, default=None
Exogenous data used in transformation.
Returns
-------
Zt : pd.Series or pd.DataFrame
Transformed version of input series `Z`.
"""
self.check_is_fitted()
zt = check_series(Z)
for _, _, transformer in self._iter_transformers():
zt = transformer.transform(zt, X)
return zt
